ThePain/Swiftgram
1
0
Fork 0
mirror of https://github.com/Swiftgram/Telegram-iOS.git synced 2025-11-06 17:00:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Lottie: optimization

Browse Source
This commit is contained in:
Isaac 2024-05-09 01:15:45 +04:00
parent 58a1caf9df
commit 99e93aadd1
4 changed files with 145 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Tests/LottieMetalTest/Sources/ViewController.swift
View File

@ -77,7 +77,8 @@ private final class ReferenceCompareTest {
let _ = await cacheReferenceAnimation(baseCachePath: baseCachePath, width: sizeMapping[fileName] ?? defaultSize, path: filePath, name: fileName) let _ = await cacheReferenceAnimation(baseCachePath: baseCachePath, width: sizeMapping[fileName] ?? defaultSize, path: filePath, name: fileName)
} }
var continueFromName: String? = "5138957708585599529.json" var continueFromName: String?
//continueFromName = "1258816259754282.json"
let _ = await processAnimationFolderAsync(basePath: bundlePath, path: "", stopOnFailure: true, process: { path, name, alwaysDraw in let _ = await processAnimationFolderAsync(basePath: bundlePath, path: "", stopOnFailure: true, process: { path, name, alwaysDraw in
if let continueFromNameValue = continueFromName { if let continueFromNameValue = continueFromName {

185
submodules/TelegramUI/Components/LottieCpp/Sources/Lottie/Private/MainThread/LayerContainers/CompLayers/PreCompositionLayer.hpp
View File

@ -102,19 +102,6 @@ public:
virtual std::shared_ptr<RenderTreeNode> renderTreeNode() override { virtual std::shared_ptr<RenderTreeNode> renderTreeNode() override {
if (!_renderTreeNode) { if (!_renderTreeNode) {
_renderTreeNode = std::make_shared<RenderTreeNode>(
CGRect(0.0, 0.0, 0.0, 0.0),
Vector2D(0.0, 0.0),
CATransform3D::identity(),
1.0,
false,
false,
nullptr,
std::vector<std::shared_ptr<RenderTreeNode>>(),
nullptr,
false
);
_contentsTreeNode = std::make_shared<RenderTreeNode>( _contentsTreeNode = std::make_shared<RenderTreeNode>(
CGRect(0.0, 0.0, 0.0, 0.0), CGRect(0.0, 0.0, 0.0, 0.0),
Vector2D(0.0, 0.0), Vector2D(0.0, 0.0),
@ -127,104 +114,72 @@ public:
nullptr, nullptr,
false false
); );
}
std::vector<std::shared_ptr<RenderTreeNode>> subnodes;
if (_contentsLayer->isHidden()) { subnodes.push_back(_contentsTreeNode);
return nullptr;
} std::shared_ptr<RenderTreeNode> maskNode;
bool invertMask = false;
std::shared_ptr<RenderTreeNode> maskNode; if (_matteLayer) {
bool invertMask = false; maskNode = _matteLayer->renderTreeNode();
if (_matteLayer) { if (maskNode && _matteType.has_value() && _matteType.value() == MatteType::Invert) {
maskNode = _matteLayer->renderTreeNode(); invertMask = true;
if (maskNode && _matteType.has_value() && _matteType.value() == MatteType::Invert) { }
invertMask = true;
} }
_renderTreeNode = std::make_shared<RenderTreeNode>(
CGRect(0.0, 0.0, 0.0, 0.0),
Vector2D(0.0, 0.0),
CATransform3D::identity(),
1.0,
false,
false,
nullptr,
subnodes,
maskNode,
invertMask
);
std::vector<std::shared_ptr<RenderTreeNode>> renderTreeSubnodes;
for (const auto &animationLayer : _animationLayers) {
bool found = false;
for (const auto &sublayer : contentsLayer()->sublayers()) {
if (animationLayer == sublayer) {
found = true;
break;
}
}
if (found) {
auto node = animationLayer->renderTreeNode();
if (node) {
renderTreeSubnodes.push_back(node);
}
}
}
std::vector<std::shared_ptr<RenderTreeNode>> renderTreeValue;
auto renderTreeContentItem = std::make_shared<RenderTreeNode>(
CGRect(0.0, 0.0, 0.0, 0.0),
Vector2D(0.0, 0.0),
CATransform3D::identity(),
1.0,
false,
false,
nullptr,
renderTreeSubnodes,
nullptr,
false
);
if (renderTreeContentItem) {
renderTreeValue.push_back(renderTreeContentItem);
}
_contentsTreeNode->_subnodes = renderTreeValue;
} }
std::vector<std::shared_ptr<RenderTreeNode>> renderTreeValue;
auto renderTreeContentItem = renderTree();
if (renderTreeContentItem) {
renderTreeValue.push_back(renderTreeContentItem);
}
std::vector<std::shared_ptr<RenderTreeNode>> subnodes;
_contentsTreeNode->_bounds = _contentsLayer->bounds();
_contentsTreeNode->_position = _contentsLayer->position();
_contentsTreeNode->_transform = _contentsLayer->transform();
_contentsTreeNode->_alpha = _contentsLayer->opacity();
_contentsTreeNode->_masksToBounds = _contentsLayer->masksToBounds();
_contentsTreeNode->_isHidden = _contentsLayer->isHidden();
_contentsTreeNode->_subnodes = renderTreeValue;
subnodes.push_back(_contentsTreeNode);
/*subnodes.push_back(std::make_shared<RenderTreeNode>(
_contentsLayer->bounds(),
_contentsLayer->position(),
_contentsLayer->transform(),
_contentsLayer->opacity(),
_contentsLayer->masksToBounds(),
_contentsLayer->isHidden(),
nullptr,
renderTreeValue,
nullptr,
false
));*/
assert(opacity() == 1.0);
assert(!isHidden());
assert(!masksToBounds());
assert(transform().isIdentity());
assert(position() == Vector2D::Zero());
_renderTreeNode->_bounds = bounds();
_renderTreeNode->_position = position();
_renderTreeNode->_transform = transform();
_renderTreeNode->_alpha = opacity();
_renderTreeNode->_masksToBounds = masksToBounds();
_renderTreeNode->_isHidden = isHidden();
_renderTreeNode->_subnodes = subnodes;
_renderTreeNode->_mask = maskNode;
_renderTreeNode->_invertMask = invertMask;
return _renderTreeNode; return _renderTreeNode;
} }
std::shared_ptr<RenderTreeNode> renderTree() {
std::vector<std::shared_ptr<RenderTreeNode>> result;
for (const auto &animationLayer : _animationLayers) {
bool found = false;
for (const auto &sublayer : contentsLayer()->sublayers()) {
if (animationLayer == sublayer) {
found = true;
break;
}
}
if (found) {
auto node = animationLayer->renderTreeNode();
if (node) {
result.push_back(node);
}
}
}
std::vector<std::shared_ptr<RenderTreeNode>> subnodes;
return std::make_shared<RenderTreeNode>(
CGRect(0.0, 0.0, 0.0, 0.0),
Vector2D(0.0, 0.0),
CATransform3D::identity(),
1.0,
false,
false,
nullptr,
result,
nullptr,
false
);
}
virtual void updateRenderTree() override { virtual void updateRenderTree() override {
if (_matteLayer) { if (_matteLayer) {
_matteLayer->updateRenderTree(); _matteLayer->updateRenderTree();
@ -242,6 +197,26 @@ public:
animationLayer->updateRenderTree(); animationLayer->updateRenderTree();
} }
} }
assert(opacity() == 1.0);
assert(!isHidden());
assert(!masksToBounds());
assert(transform().isIdentity());
assert(position() == Vector2D::Zero());
_contentsTreeNode->_bounds = _contentsLayer->bounds();
_contentsTreeNode->_position = _contentsLayer->position();
_contentsTreeNode->_transform = _contentsLayer->transform();
_contentsTreeNode->_alpha = _contentsLayer->opacity();
_contentsTreeNode->_masksToBounds = _contentsLayer->masksToBounds();
_contentsTreeNode->_isHidden = _contentsLayer->isHidden();
_renderTreeNode->_bounds = bounds();
_renderTreeNode->_position = position();
_renderTreeNode->_transform = transform();
_renderTreeNode->_alpha = opacity();
_renderTreeNode->_masksToBounds = masksToBounds();
_renderTreeNode->_isHidden = isHidden();
} }
private: private:

60
submodules/TelegramUI/Components/LottieCpp/Sources/Lottie/Private/MainThread/LayerContainers/CompLayers/ShapeCompositionLayer.cpp
View File

@ -1295,19 +1295,6 @@ std::shared_ptr<RenderTreeNode> ShapeCompositionLayer::renderTreeNode() {
} }
if (!_renderTreeNode) { if (!_renderTreeNode) {
_renderTreeNode = std::make_shared<RenderTreeNode>(
CGRect(0.0, 0.0, 0.0, 0.0),
Vector2D(0.0, 0.0),
CATransform3D::identity(),
1.0,
false,
false,
nullptr,
std::vector<std::shared_ptr<RenderTreeNode>>(),
nullptr,
false
);
std::vector<std::shared_ptr<RenderTreeNode>> renderTreeValue; std::vector<std::shared_ptr<RenderTreeNode>> renderTreeValue;
renderTreeValue.push_back(_contentTree->itemTree->renderTree()); renderTreeValue.push_back(_contentTree->itemTree->renderTree());
@ -1323,15 +1310,39 @@ std::shared_ptr<RenderTreeNode> ShapeCompositionLayer::renderTreeNode() {
nullptr, nullptr,
false false
); );
std::vector<std::shared_ptr<RenderTreeNode>> subnodes;
subnodes.push_back(_contentsTreeNode);
std::shared_ptr<RenderTreeNode> maskNode;
bool invertMask = false;
if (_matteLayer) {
maskNode = _matteLayer->renderTreeNode();
if (maskNode && _matteType.has_value() && _matteType.value() == MatteType::Invert) {
invertMask = true;
}
}
_renderTreeNode = std::make_shared<RenderTreeNode>(
CGRect(0.0, 0.0, 0.0, 0.0),
Vector2D(0.0, 0.0),
CATransform3D::identity(),
1.0,
false,
false,
nullptr,
subnodes,
maskNode,
invertMask
);
} }
std::shared_ptr<RenderTreeNode> maskNode; return _renderTreeNode;
bool invertMask = false; }
void ShapeCompositionLayer::updateRenderTree() {
if (_matteLayer) { if (_matteLayer) {
maskNode = _matteLayer->renderTreeNode(); _matteLayer->updateRenderTree();
if (maskNode && _matteType.has_value() && _matteType.value() == MatteType::Invert) {
invertMask = true;
}
} }
_contentsTreeNode->_bounds = _contentsLayer->bounds(); _contentsTreeNode->_bounds = _contentsLayer->bounds();
@ -1341,9 +1352,6 @@ std::shared_ptr<RenderTreeNode> ShapeCompositionLayer::renderTreeNode() {
_contentsTreeNode->_masksToBounds = _contentsLayer->masksToBounds(); _contentsTreeNode->_masksToBounds = _contentsLayer->masksToBounds();
_contentsTreeNode->_isHidden = _contentsLayer->isHidden(); _contentsTreeNode->_isHidden = _contentsLayer->isHidden();
std::vector<std::shared_ptr<RenderTreeNode>> subnodes;
subnodes.push_back(_contentsTreeNode);
assert(position() == Vector2D::Zero()); assert(position() == Vector2D::Zero());
assert(transform().isIdentity()); assert(transform().isIdentity());
assert(opacity() == 1.0); assert(opacity() == 1.0);
@ -1359,14 +1367,6 @@ std::shared_ptr<RenderTreeNode> ShapeCompositionLayer::renderTreeNode() {
_renderTreeNode->_alpha = opacity(); _renderTreeNode->_alpha = opacity();
_renderTreeNode->_masksToBounds = masksToBounds(); _renderTreeNode->_masksToBounds = masksToBounds();
_renderTreeNode->_isHidden = isHidden(); _renderTreeNode->_isHidden = isHidden();
_renderTreeNode->_subnodes = subnodes;
_renderTreeNode->_mask = maskNode;
_renderTreeNode->_invertMask = invertMask;
return _renderTreeNode;
}
void ShapeCompositionLayer::updateRenderTree() {
} }
} }

59
submodules/TelegramUI/Components/LottieCpp/Sources/Lottie/Private/MainThread/LayerContainers/MainThreadAnimationLayer.hpp
View File

@ -219,38 +219,43 @@ public:
} }
virtual std::shared_ptr<RenderTreeNode> renderTreeNode() { virtual std::shared_ptr<RenderTreeNode> renderTreeNode() {
std::vector<std::shared_ptr<RenderTreeNode>> subnodes; if (!_renderTreeNode) {
for (const auto &animationLayer : _animationLayers) { std::vector<std::shared_ptr<RenderTreeNode>> subnodes;
bool found = false; for (const auto &animationLayer : _animationLayers) {
for (const auto &sublayer : sublayers()) { bool found = false;
if (animationLayer == sublayer) { for (const auto &sublayer : sublayers()) {
found = true; if (animationLayer == sublayer) {
break; found = true;
} break;
} }
if (found) { }
auto node = animationLayer->renderTreeNode(); if (found) {
if (node) { auto node = animationLayer->renderTreeNode();
subnodes.push_back(node); if (node) {
subnodes.push_back(node);
}
} }
} }
_renderTreeNode = std::make_shared<RenderTreeNode>(
bounds(),
position(),
CATransform3D::identity(),
1.0,
false,
false,
nullptr,
subnodes,
nullptr,
false
);
} }
return std::make_shared<RenderTreeNode>( updateRenderTree();
bounds(),
position(), return _renderTreeNode;
CATransform3D::identity(),
1.0,
false,
false,
nullptr,
subnodes,
nullptr,
false
);
} }
virtual void updateRenderTree() { void updateRenderTree() {
for (const auto &animationLayer : _animationLayers) { for (const auto &animationLayer : _animationLayers) {
bool found = false; bool found = false;
for (const auto &sublayer : sublayers()) { for (const auto &sublayer : sublayers()) {
@ -282,6 +287,8 @@ private:
std::shared_ptr<LayerImageProvider> _layerImageProvider; std::shared_ptr<LayerImageProvider> _layerImageProvider;
std::shared_ptr<LayerTextProvider> _layerTextProvider; std::shared_ptr<LayerTextProvider> _layerTextProvider;
std::shared_ptr<LayerFontProvider> _layerFontProvider; std::shared_ptr<LayerFontProvider> _layerFontProvider;
std::shared_ptr<RenderTreeNode> _renderTreeNode;
}; };
} }