ZaStoGram_desktop/Telegram/SourceFiles/ui/effects/peer_qr_emoji_field.cpp
John Preston 6b3d996c16 Choose collectible gifts as the QR box appearance.
Task: 2026/10/15/choose-a-unique-gift-for-the-qr-box
2026-10-20 17:07:54 +04:00

524 lines
14 KiB
C++

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "ui/effects/peer_qr_emoji_field.h"
#include "ui/effects/animation_value.h"
#include "ui/text/text_custom_emoji.h"
#include "styles/style_boxes.h"
namespace Ui {
namespace {
constexpr auto kEmptyShare = 0.2;
constexpr auto kBigTier = 1.17;
constexpr auto kSmallTier = 0.9;
constexpr auto kNodeScaleMin = 0.92;
constexpr auto kNodeScaleMax = 1.08;
constexpr auto kTiltMax = 13.;
constexpr auto kSwayAngle = 4.;
constexpr auto kSwaySpeed = 0.3;
constexpr auto kBobSpeed = 0.45;
constexpr auto kScaleCutoff = 0.05;
constexpr auto kCardShrink = 0.03;
constexpr auto kEntryStagger = crl::time(60);
constexpr auto kPopDuration = crl::time(315);
constexpr auto kShrinkDuration = crl::time(180);
constexpr auto kPopDelay = crl::time(135);
constexpr auto kSwapStagger = crl::time(300);
constexpr auto kSwapDuration = kSwapStagger
+ std::max(kShrinkDuration, kPopDelay + kPopDuration);
enum class Salt : uint32 {
Empty = 1,
Scale,
Tilt,
Radius,
Angle,
Sway,
Bob,
Delay,
};
struct Tile {
QPointF center;
float64 size = 0.;
float64 rotation = 0.;
float64 delay = 0.;
int row = 0;
int column = 0;
int pick = 0;
};
[[nodiscard]] float64 NodeRandom(int row, int column, Salt salt) {
return PeerQrNodeHash(row, column, uint32(salt)) / 4294967296.;
}
[[nodiscard]] int PickIndex(int row, int column, int count) {
const auto q = column - (row - (row & 1)) / 2;
const auto index = (q - row) % count;
return (index < 0) ? (index + count) : index;
}
template <typename Callback>
void EnumerateTiles(
const PeerQrLayerFalloff &falloff,
QPointF origin,
const PeerQrEmojiMetrics &metrics,
int count,
float64 seconds,
Callback &&callback) {
if (count <= 0 || metrics.skipX <= 0. || metrics.skipY <= 0.) {
return;
}
const auto reach = falloff.reach(metrics.offsetMax
+ metrics.bob
+ metrics.size * kBigTier * kNodeScaleMax / 2.);
const auto rowFrom = int(std::ceil(
(reach.top() - origin.y()) / metrics.skipY));
const auto rowTill = int(std::floor(
(reach.bottom() - origin.y()) / metrics.skipY));
for (auto row = rowFrom; row <= rowTill; ++row) {
const auto odd = (row & 1) != 0;
const auto shift = odd ? 0.5 : 0.;
const auto tier = odd ? kSmallTier : kBigTier;
const auto columnFrom = int(std::ceil(
(reach.left() - origin.x()) / metrics.skipX - shift));
const auto columnTill = int(std::floor(
(reach.right() - origin.x()) / metrics.skipX - shift));
for (auto column = columnFrom; column <= columnTill; ++column) {
const auto random = [&](Salt salt) {
return NodeRandom(row, column, salt);
};
if (random(Salt::Empty) < kEmptyShare) {
continue;
}
const auto spread = metrics.offsetMax - metrics.offsetMin;
const auto radius = metrics.offsetMin
+ spread * random(Salt::Radius);
const auto angle = 2. * M_PI * random(Salt::Angle);
const auto bob = metrics.bob * std::sin(
kBobSpeed * seconds + 2. * M_PI * random(Salt::Bob));
const auto flat = origin + QPointF(
(column + shift) * metrics.skipX + radius * std::cos(angle),
row * metrics.skipY + radius * std::sin(angle) + bob);
const auto scale = kNodeScaleMin
+ (kNodeScaleMax - kNodeScaleMin) * random(Salt::Scale);
const auto size = metrics.size * tier * scale;
const auto place = PeerQrPlaceItem(falloff, flat, size);
if (!place) {
continue;
}
const auto tilt = kTiltMax * (2. * random(Salt::Tilt) - 1.);
const auto sway = kSwayAngle * std::sin(
kSwaySpeed * seconds + 2. * M_PI * random(Salt::Sway));
callback(Tile{
.center = place->position,
.size = size * place->scale,
.rotation = tilt + sway,
.delay = random(Salt::Delay),
.row = row,
.column = column,
.pick = PickIndex(row, column, count),
});
}
}
}
[[nodiscard]] float64 PopScale(crl::time now, crl::time start) {
if (now <= start) {
return 0.;
} else if (now >= start + kPopDuration) {
return 1.;
}
return anim::easeOutBack(1., float64(now - start) / kPopDuration);
}
[[nodiscard]] float64 ShrinkScale(crl::time now, crl::time start) {
if (now <= start) {
return 1.;
} else if (now >= start + kShrinkDuration) {
return 0.;
}
return 1. - anim::easeInCubic(1., float64(now - start) / kShrinkDuration);
}
} // namespace
uint32 PeerQrHash(uint32 value) {
value ^= value >> 16;
value *= 0x7FEB352DU;
value ^= value >> 15;
value *= 0x846CA68BU;
value ^= value >> 16;
return value;
}
uint32 PeerQrNodeHash(int row, int column, uint32 salt) {
const auto seeded = PeerQrHash(salt * 0x9E3779B9U + uint32(row));
return PeerQrHash(seeded ^ (uint32(column) * 0x85EBCA6BU));
}
QImage PeerQrRenderStill(
not_null<Text::CustomEmoji*> art,
int frameSize,
QColor textColor) {
const auto ratio = style::DevicePixelRatio();
auto result = QImage(
QSize(frameSize, frameSize) * ratio,
QImage::Format_ARGB32_Premultiplied);
result.setDevicePixelRatio(ratio);
result.fill(Qt::transparent);
auto p = QPainter(&result);
art->paint(p, {
.textColor = textColor,
.internal = { .forceFirstFrame = true },
});
p.end();
return result;
}
void PeerQrApplyItemTransform(
QPainter &p,
const QTransform &base,
QPointF center,
float64 rotation,
float64 size,
float64 frame) {
auto transform = base;
transform.translate(center.x(), center.y());
transform.rotate(rotation);
transform.scale(size / frame, size / frame);
transform.translate(-frame / 2., -frame / 2.);
p.setTransform(transform);
}
std::optional<PeerQrLayerPlace> PeerQrPlaceItem(
const PeerQrLayerFalloff &falloff,
QPointF flat,
float64 size) {
const auto place = falloff.place(flat);
if (place.scale < kScaleCutoff) {
return std::nullopt;
}
const auto extent = size * place.scale / M_SQRT2;
const auto bounds = QRectF(
place.position - QPointF(extent, extent),
QSizeF(2. * extent, 2. * extent));
if (!bounds.intersects(falloff.area)) {
return std::nullopt;
}
return place;
}
QRectF PeerQrCardCull(QRectF card) {
const auto x = card.width() * kCardShrink / 2.;
const auto y = card.height() * kCardShrink / 2.;
return card.marginsRemoved({ x, y, x, y });
}
// WHY: the card's corner radius is unknown here; a tile inside the ellipse
// inscribed in the dipped card is covered for any reasonable radius.
bool PeerQrCovered(const QRectF &cull, QPointF center, float64 size) {
if (cull.isEmpty()) {
return false;
}
const auto radius = size / M_SQRT2;
const auto middle = cull.center();
const auto x = (std::abs(center.x() - middle.x()) + radius)
/ (cull.width() / 2.);
const auto y = (std::abs(center.y() - middle.y()) + radius)
/ (cull.height() / 2.);
return (x * x + y * y) <= 1.;
}
PeerQrEmojiMetrics PeerQrEmojiMetrics::Live() {
return {
.skipX = float64(st::peerQrEmojiSkipX),
.skipY = float64(st::peerQrEmojiSkipY),
.size = float64(st::peerQrEmojiSize),
.offsetMin = float64(st::peerQrEmojiOffsetMin),
.offsetMax = float64(st::peerQrEmojiOffsetMax),
.bob = float64(st::peerQrEmojiBob),
};
}
void PaintPeerQrEmojiRest(
QPainter &p,
const PeerQrLayerFalloff &falloff,
QPointF origin,
QRectF card,
const PeerQrEmojiRest &rest) {
const auto count = int(rest.stills.size());
if (!count) {
return;
}
const auto cull = PeerQrCardCull(card);
p.save();
p.setRenderHint(QPainter::SmoothPixmapTransform);
const auto base = p.transform();
const auto paint = [&](const Tile &tile) {
const auto &still = rest.stills[tile.pick];
if (still.isNull() || PeerQrCovered(cull, tile.center, tile.size)) {
return;
}
const auto frame = QRectF(QPointF(), QSizeF(still.size()));
PeerQrApplyItemTransform(
p,
base,
tile.center,
tile.rotation,
tile.size,
frame.width());
p.drawImage(frame, still);
};
EnumerateTiles(falloff, origin, rest.metrics, count, 0., paint);
p.restore();
}
PeerQrEmojiField::PeerQrEmojiField(
PeerQrEmojiSource source,
Fn<void()> repaint)
: _source(std::move(source))
, _repaint(std::move(repaint))
, _textColor(st::windowFg->c) {
}
PeerQrEmojiField::~PeerQrEmojiField() = default;
void PeerQrEmojiField::setSource(PeerQrEmojiSource source) {
const auto resized = (_source.frameSize != source.frameSize);
_source = std::move(source);
auto created = false;
for (auto &pick : _picks) {
if (!pick.emoji) {
pick.emoji = createEmoji(pick.key);
created = created || (pick.emoji != nullptr);
}
}
if ((created || resized) && _repaint) {
_repaint();
}
}
void PeerQrEmojiField::setPicks(
std::vector<QString> keys,
PeerQrEmojiChange change,
crl::time now) {
auto unique = std::vector<QString>();
unique.reserve(keys.size());
for (auto &key : keys) {
if (!ranges::contains(unique, key)) {
unique.push_back(std::move(key));
}
}
const auto same = ranges::equal(
unique,
_picks,
ranges::equal_to(),
ranges::identity(),
&Pick::key);
if (same && change != PeerQrEmojiChange::Entry) {
return;
}
auto previous = _picks
| ranges::views::transform(&Pick::key)
| ranges::to_vector;
auto removed = base::take(_picks);
const auto take = [&](std::vector<Pick> &from, const QString &key) {
const auto i = ranges::find(from, key, &Pick::key);
if (i == end(from)) {
return false;
}
_picks.push_back(std::move(*i));
from.erase(i);
return true;
};
for (const auto &key : unique) {
if (!take(removed, key) && !take(_leaving, key)) {
_picks.push_back({ .key = key, .emoji = createEmoji(key) });
}
}
const auto settled = now - kEntryStagger - kPopDuration;
const auto instant = (change == PeerQrEmojiChange::Instant);
const auto readyAt = instant ? settled : now;
for (auto &pick : _picks) {
if (pick.readyAt) {
pick.readyAt = std::min(pick.readyAt, readyAt);
} else if (pick.emoji && pick.emoji->ready()) {
pick.readyAt = readyAt;
}
}
if (change == PeerQrEmojiChange::Swap) {
_previous = std::move(previous);
_leaving = std::move(removed);
_changedAt = now;
return;
}
finishSwap();
_entryAt = std::nullopt;
if (instant) {
_entryAt = settled;
}
}
void PeerQrEmojiField::startEntry(crl::time now) {
if (!_entryAt) {
finishSwap();
_entryAt = now;
}
}
void PeerQrEmojiField::setTextColor(QColor color) {
_textColor = color;
}
void PeerQrEmojiField::paint(QPainter &p, const PeerQrEmojiPaint &args) {
const auto metrics = PeerQrEmojiMetrics::Live();
const auto now = args.now;
refreshReady(now);
if (_changedAt && now >= _changedAt + kSwapDuration) {
finishSwap();
}
if (_picks.empty() || !_entryAt || _source.frameSize <= 0) {
return;
}
const auto previous = _previous
| ranges::views::transform([&](const QString &key) {
return findPick(key);
})
| ranges::to_vector;
const auto entryAt = *_entryAt;
const auto instant = anim::Disabled();
const auto frame = float64(_source.frameSize);
const auto cull = PeerQrCardCull(args.card);
const auto appearAt = [&](const Pick &pick, const Tile &tile) {
return std::max(entryAt, pick.readyAt)
+ crl::time(kEntryStagger * tile.delay);
};
p.save();
p.setRenderHint(QPainter::SmoothPixmapTransform);
const auto base = p.transform();
const auto draw = [&](const Pick &pick, const Tile &tile, float64 scale) {
const auto size = tile.size * scale;
if (!pick.emoji
|| size <= 0.
|| PeerQrCovered(cull, tile.center, size)) {
return;
}
PeerQrApplyItemTransform(
p,
base,
tile.center,
tile.rotation,
size,
frame);
pick.emoji->paint(p, {
.textColor = _textColor,
.now = now,
.paused = args.paused,
});
};
const auto paintTile = [&](const Tile &tile) {
const auto &pick = _picks[tile.pick];
const auto old = previous.empty()
? nullptr
: previous[PickIndex(tile.row, tile.column, int(previous.size()))];
const auto changed = _changedAt && (old != &pick);
const auto delayed = _changedAt
+ crl::time(kSwapStagger * tile.delay);
if (changed && old && old->readyAt && !instant) {
draw(
*old,
tile,
(PopScale(now, appearAt(*old, tile))
* ShrinkScale(now, delayed)));
}
if (pick.readyAt) {
const auto start = changed
? std::max(appearAt(pick, tile), delayed + kPopDelay)
: appearAt(pick, tile);
draw(pick, tile, instant ? 1. : PopScale(now, start));
}
};
EnumerateTiles(
args.falloff,
args.origin,
metrics,
int(_picks.size()),
args.elapsed / 1000.,
paintTile);
p.restore();
}
bool PeerQrEmojiField::animating(crl::time now) const {
if (_picks.empty() || anim::Disabled()) {
return false;
} else if (!_entryAt || (_changedAt && now < _changedAt + kSwapDuration)) {
return true;
}
const auto entryAt = *_entryAt;
return ranges::any_of(_picks, [&](const Pick &pick) {
return pick.readyAt
&& (now < std::max(entryAt, pick.readyAt)
+ kEntryStagger
+ kPopDuration);
});
}
PeerQrEmojiRest PeerQrEmojiField::prepareRest(
PeerQrEmojiMetrics metrics) const {
auto stills = std::vector<QImage>();
stills.reserve(_picks.size());
for (const auto &pick : _picks) {
const auto shown = pick.emoji
&& pick.readyAt
&& (_source.frameSize > 0);
stills.push_back(shown
? PeerQrRenderStill(pick.emoji.get(), _source.frameSize, _textColor)
: QImage());
}
return { .stills = std::move(stills), .metrics = metrics };
}
std::unique_ptr<Text::CustomEmoji> PeerQrEmojiField::createEmoji(
const QString &key) const {
return _source.factory
? _source.factory(key, Text::MarkedContext{ .repaint = _repaint })
: nullptr;
}
const PeerQrEmojiField::Pick *PeerQrEmojiField::findPick(
const QString &key) const {
for (const auto list : { &_picks, &_leaving }) {
const auto i = ranges::find(*list, key, &Pick::key);
if (i != end(*list)) {
return &*i;
}
}
return nullptr;
}
void PeerQrEmojiField::refreshReady(crl::time now) {
if (_source.frameSize <= 0) {
return;
}
for (auto &pick : _picks) {
if (pick.emoji && !pick.readyAt && pick.emoji->ready()) {
pick.readyAt = now;
}
}
}
void PeerQrEmojiField::finishSwap() {
_previous.clear();
_leaving.clear();
_changedAt = 0;
}
} // namespace Ui