ZaStoGram_desktop/Telegram/SourceFiles/ui/effects/peer_qr_gift_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

425 lines
12 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_gift_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 kModelScaleMin = 0.93;
constexpr auto kModelScaleMax = 1.07;
constexpr auto kModelTilt = 11.;
constexpr auto kSymbolScaleMin = 0.75;
constexpr auto kSymbolScaleRange = 0.5;
constexpr auto kSymbolEmptyShare = 0.39;
constexpr auto kSymbolAlpha = 0.37;
constexpr auto kClearance = 0.8;
constexpr auto kModelPopDuration = crl::time(315);
constexpr auto kModelStagger = crl::time(200);
constexpr auto kSymbolFadeDuration = crl::time(300);
constexpr auto kSymbolStagger = crl::time(300);
constexpr auto kEntryDuration = std::max(
kSymbolStagger + kSymbolFadeDuration,
kModelStagger + kModelPopDuration);
enum class Salt : uint32 {
ModelRadius = 101,
ModelAngle,
ModelScale,
ModelTilt,
ModelDelay,
SymbolEmpty,
SymbolX,
SymbolY,
SymbolHeight,
SymbolDelay,
};
struct Item {
QPointF center;
float64 size = 0.;
float64 rotation = 0.;
float64 delay = 0.;
};
[[nodiscard]] float64 NodeRandom(int row, int column, Salt salt) {
return PeerQrNodeHash(row, column, uint32(salt)) / 4294967296.;
}
[[nodiscard]] std::pair<QPointF, float64> ModelFlat(
int row,
int column,
QPointF origin,
const PeerQrGiftMetrics &metrics) {
const auto random = [&](Salt salt) {
return NodeRandom(row, column, salt);
};
const auto shift = (row & 1) ? 0.5 : 0.;
const auto radius = metrics.modelOffset * random(Salt::ModelRadius);
const auto angle = 2. * M_PI * random(Salt::ModelAngle);
const auto flat = origin + QPointF(
(column + shift) * metrics.modelSkipX + radius * std::cos(angle),
row * metrics.modelSkipY + radius * std::sin(angle));
const auto size = metrics.modelSize * (kModelScaleMin
+ (kModelScaleMax - kModelScaleMin) * random(Salt::ModelScale));
return { flat, size };
}
[[nodiscard]] bool NearModel(
QPointF flat,
float64 size,
QPointF origin,
const PeerQrGiftMetrics &metrics) {
const auto relative = flat - origin;
const auto rowNear = int(std::round(relative.y() / metrics.modelSkipY));
for (auto row = rowNear - 1; row <= rowNear + 1; ++row) {
const auto shift = (row & 1) ? 0.5 : 0.;
const auto columnNear = int(std::round(
relative.x() / metrics.modelSkipX - shift));
for (auto column = columnNear - 1; column <= columnNear + 1; ++column) {
const auto [model, modelSize] = ModelFlat(
row,
column,
origin,
metrics);
const auto delta = flat - model;
const auto clearance = kClearance * (modelSize + size) / 2.;
if (QPointF::dotProduct(delta, delta) < clearance * clearance) {
return true;
}
}
}
return false;
}
template <typename Callback>
void EnumerateModels(
const PeerQrLayerFalloff &falloff,
QPointF origin,
const PeerQrGiftMetrics &metrics,
Callback &&callback) {
if (metrics.modelSkipX <= 0. || metrics.modelSkipY <= 0.) {
return;
}
const auto reach = falloff.reach(metrics.modelOffset
+ metrics.modelSize * kModelScaleMax / M_SQRT2);
const auto rowFrom = int(std::ceil(
(reach.top() - origin.y()) / metrics.modelSkipY));
const auto rowTill = int(std::floor(
(reach.bottom() - origin.y()) / metrics.modelSkipY));
for (auto row = rowFrom; row <= rowTill; ++row) {
const auto shift = (row & 1) ? 0.5 : 0.;
const auto columnFrom = int(std::ceil(
(reach.left() - origin.x()) / metrics.modelSkipX - shift));
const auto columnTill = int(std::floor(
(reach.right() - origin.x()) / metrics.modelSkipX - shift));
for (auto column = columnFrom; column <= columnTill; ++column) {
const auto [flat, size] = ModelFlat(row, column, origin, metrics);
const auto place = PeerQrPlaceItem(falloff, flat, size);
if (!place) {
continue;
}
const auto random = [&](Salt salt) {
return NodeRandom(row, column, salt);
};
callback(Item{
.center = place->position,
.size = size * place->scale,
.rotation = kModelTilt * (2. * random(Salt::ModelTilt) - 1.),
.delay = random(Salt::ModelDelay),
});
}
}
}
template <typename Callback>
void EnumerateSymbols(
const PeerQrLayerFalloff &falloff,
QPointF origin,
const PeerQrGiftMetrics &metrics,
Callback &&callback) {
if (metrics.symbolSkipX <= 0.
|| metrics.symbolSkipY <= 0.
|| metrics.modelSkipX <= 0.
|| metrics.modelSkipY <= 0.) {
return;
}
const auto reach = falloff.reach(
std::max(metrics.symbolJitterX, metrics.symbolJitterY)
+ metrics.symbolSize * (kSymbolScaleMin + kSymbolScaleRange) / 2.);
const auto rowFrom = int(std::ceil(
(reach.top() - origin.y()) / metrics.symbolSkipY));
const auto rowTill = int(std::floor(
(reach.bottom() - origin.y()) / metrics.symbolSkipY));
for (auto row = rowFrom; row <= rowTill; ++row) {
const auto shift = (row & 1) ? 0.5 : 0.;
const auto columnFrom = int(std::ceil(
(reach.left() - origin.x()) / metrics.symbolSkipX - shift));
const auto columnTill = int(std::floor(
(reach.right() - origin.x()) / metrics.symbolSkipX - shift));
for (auto column = columnFrom; column <= columnTill; ++column) {
const auto random = [&](Salt salt) {
return NodeRandom(row, column, salt);
};
if (random(Salt::SymbolEmpty) < kSymbolEmptyShare) {
continue;
}
const auto jitter = QPointF(
metrics.symbolJitterX * (2. * random(Salt::SymbolX) - 1.),
metrics.symbolJitterY * (2. * random(Salt::SymbolY) - 1.));
const auto flat = origin + jitter + QPointF(
(column + shift) * metrics.symbolSkipX,
row * metrics.symbolSkipY);
const auto height = random(Salt::SymbolHeight);
const auto size = metrics.symbolSize
* (kSymbolScaleMin + kSymbolScaleRange * height * height);
const auto place = PeerQrPlaceItem(falloff, flat, size);
if (!place || NearModel(flat, size, origin, metrics)) {
continue;
}
callback(Item{
.center = place->position,
.size = size * place->scale,
.delay = random(Salt::SymbolDelay),
});
}
}
}
[[nodiscard]] QRectF ItemRect(const Item &item) {
const auto half = item.size / 2.;
return QRectF(
item.center - QPointF(half, half),
QSizeF(item.size, item.size));
}
[[nodiscard]] float64 EntryProgress(
crl::time now,
crl::time start,
crl::time duration) {
return std::clamp(float64(now - start) / duration, 0., 1.);
}
} // namespace
PeerQrGiftMetrics PeerQrGiftMetrics::Live() {
return {
.modelSize = float64(st::peerQrGiftModelSize),
.modelSkipX = float64(st::peerQrGiftModelSkipX),
.modelSkipY = float64(st::peerQrGiftModelSkipY),
.modelOffset = float64(st::peerQrGiftModelOffset),
.symbolSize = float64(st::peerQrGiftSymbolSize),
.symbolSkipX = float64(st::peerQrGiftSymbolSkipX),
.symbolSkipY = float64(st::peerQrGiftSymbolSkipY),
.symbolJitterX = float64(st::peerQrGiftSymbolJitterX),
.symbolJitterY = float64(st::peerQrGiftSymbolJitterY),
};
}
void PaintPeerQrGiftRest(
QPainter &p,
const PeerQrLayerFalloff &falloff,
QPointF origin,
QRectF card,
const PeerQrGiftRest &rest) {
if (rest.model.isNull() && rest.symbol.isNull()) {
return;
}
const auto cull = PeerQrCardCull(card);
p.save();
p.setRenderHint(QPainter::SmoothPixmapTransform);
if (!rest.symbol.isNull()) {
p.setOpacity(kSymbolAlpha);
EnumerateSymbols(falloff, origin, rest.metrics, [&](const Item &item) {
if (!PeerQrCovered(cull, item.center, item.size)) {
p.drawImage(ItemRect(item), rest.symbol);
}
});
p.setOpacity(1.);
}
if (!rest.model.isNull()) {
const auto base = p.transform();
const auto frame = QRectF(QPointF(), QSizeF(rest.model.size()));
EnumerateModels(falloff, origin, rest.metrics, [&](const Item &item) {
if (!PeerQrCovered(cull, item.center, item.size)) {
PeerQrApplyItemTransform(
p,
base,
item.center,
item.rotation,
item.size,
frame.width());
p.drawImage(frame, rest.model);
}
});
}
p.restore();
}
PeerQrGiftField::PeerQrGiftField(
PeerQrGiftSource source,
PeerQrGiftLook look,
Fn<void()> repaint,
bool instant)
: _source(std::move(source))
, _look(std::move(look))
, _repaint(std::move(repaint)) {
if (instant) {
const auto settled = crl::now() - kSymbolStagger - kSymbolFadeDuration;
_entryAt = settled;
createArt();
validateSymbol(settled);
if (_model && _model->ready()) {
_modelReadyAt = settled;
}
}
}
PeerQrGiftField::~PeerQrGiftField() = default;
const PeerQrGiftLook &PeerQrGiftField::look() const {
return _look;
}
void PeerQrGiftField::setSource(PeerQrGiftSource source) {
if (_source.patternFrame != source.patternFrame) {
_symbol = QImage();
}
_source = std::move(source);
if (_repaint) {
_repaint();
}
}
void PeerQrGiftField::startEntry(crl::time now) {
if (!_entryAt) {
_entryAt = now;
}
}
void PeerQrGiftField::paint(QPainter &p, const PeerQrEmojiPaint &args) {
const auto now = args.now;
createArt();
validateSymbol(now);
if (_model && !_modelReadyAt && _model->ready()) {
_modelReadyAt = now;
}
if (!_entryAt) {
return;
}
const auto metrics = PeerQrGiftMetrics::Live();
const auto entryAt = *_entryAt;
const auto instant = anim::Disabled();
const auto cull = PeerQrCardCull(args.card);
p.save();
p.setRenderHint(QPainter::SmoothPixmapTransform);
if (!_symbol.isNull()) {
const auto start = std::max(entryAt, _symbolReadyAt);
const auto paintSymbol = [&](const Item &item) {
const auto fade = instant ? 1. : anim::easeOutCubic(
1.,
EntryProgress(
now,
start + crl::time(kSymbolStagger * item.delay),
kSymbolFadeDuration));
if (fade <= 0. || PeerQrCovered(cull, item.center, item.size)) {
return;
}
p.setOpacity(kSymbolAlpha * fade);
p.drawImage(ItemRect(item), _symbol);
};
EnumerateSymbols(args.falloff, args.origin, metrics, paintSymbol);
p.setOpacity(1.);
}
const auto frame = _modelReadyAt ? float64(_model->width()) : 0.;
if (frame > 0.) {
const auto start = std::max(entryAt, _modelReadyAt);
const auto base = p.transform();
const auto paintModel = [&](const Item &item) {
const auto scale = instant ? 1. : anim::easeOutBack(
1.,
EntryProgress(
now,
start + crl::time(kModelStagger * item.delay),
kModelPopDuration));
const auto size = item.size * scale;
if (size <= 0. || PeerQrCovered(cull, item.center, size)) {
return;
}
PeerQrApplyItemTransform(
p,
base,
item.center,
item.rotation,
size,
frame);
_model->paint(p, {
.textColor = QColor(255, 255, 255),
.now = now,
.paused = args.paused,
});
};
EnumerateModels(args.falloff, args.origin, metrics, paintModel);
}
p.restore();
}
bool PeerQrGiftField::animating(crl::time now) const {
if (anim::Disabled()) {
return false;
} else if (!_entryAt) {
return true;
}
const auto entryAt = *_entryAt;
const auto entering = [&](crl::time readyAt) {
return readyAt && (now < std::max(entryAt, readyAt) + kEntryDuration);
};
return entering(_modelReadyAt) || entering(_symbolReadyAt);
}
PeerQrGiftRest PeerQrGiftField::prepareRest(PeerQrGiftMetrics metrics) const {
const auto frame = (_model && _model->ready()) ? _model->width() : 0;
return {
.model = ((frame > 0)
? PeerQrRenderStill(_model.get(), frame, QColor(255, 255, 255))
: QImage()),
.symbol = _symbol,
.metrics = metrics,
};
}
void PeerQrGiftField::createArt() {
if (!_model && _source.model && !_look.model.isEmpty()) {
_model = _source.model(_look.model, _repaint);
}
if (!_pattern && _source.pattern && !_look.pattern.isEmpty()) {
_pattern = _source.pattern(_look.pattern, _repaint);
}
}
void PeerQrGiftField::validateSymbol(crl::time now) {
if (!_symbol.isNull()
|| !_pattern
|| _source.patternFrame <= 0
|| !_pattern->ready()) {
return;
}
_symbol = PeerQrRenderStill(
_pattern.get(),
_source.patternFrame,
_look.patternColor);
if (!_symbolReadyAt) {
_symbolReadyAt = now;
}
}
} // namespace Ui