1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#undef QT_NO_FOREACH // this file contains unported legacy Q_FOREACH uses
#include "qquickparticlepainter_p.h"
#include <QQuickWindow>
#include <QDebug>
QT_BEGIN_NAMESPACE
/*!
\qmltype ParticlePainter
\instantiates QQuickParticlePainter
\inqmlmodule QtQuick.Particles
\inherits Item
\brief For specifying how to paint particles.
\ingroup qtquick-particles
The default implementation paints nothing. See the subclasses if you want to
paint something visible.
*/
/*!
\qmlproperty ParticleSystem QtQuick.Particles::ParticlePainter::system
This is the system whose particles can be painted by the element.
If the ParticlePainter is a direct child of a ParticleSystem, it will automatically be associated with it.
*/
/*!
\qmlproperty list<string> QtQuick.Particles::ParticlePainter::groups
Which logical particle groups will be painted.
If empty, it will paint the default particle group ("").
*/
QQuickParticlePainter::QQuickParticlePainter(QQuickItem *parent)
: QQuickItem(parent)
, m_system(nullptr)
, m_count(0)
, m_pleaseReset(true)
, m_window(nullptr)
, m_windowChanged(false)
, m_groupIdsNeedRecalculation(false)
{
}
void QQuickParticlePainter::itemChange(ItemChange change, const ItemChangeData &data)
{
if (change == QQuickItem::ItemSceneChange) {
if (m_window) {
disconnect(m_window, &QQuickWindow::sceneGraphInvalidated,
this, &QQuickParticlePainter::sceneGraphInvalidated);
}
m_window = data.window;
m_windowChanged = true;
if (m_window) {
connect(m_window, &QQuickWindow::sceneGraphInvalidated,
this, &QQuickParticlePainter::sceneGraphInvalidated, Qt::DirectConnection);
}
}
QQuickItem::itemChange(change, data);
}
void QQuickParticlePainter::componentComplete()
{
if (!m_system && qobject_cast<QQuickParticleSystem*>(parentItem()))
setSystem(qobject_cast<QQuickParticleSystem*>(parentItem()));
QQuickItem::componentComplete();
}
void QQuickParticlePainter::recalculateGroupIds() const
{
if (!m_system) {
m_groupIds.clear();
return;
}
m_groupIdsNeedRecalculation = false;
m_groupIds.clear();
const auto groupList = groups();
for (const QString &str : groupList) {
QQuickParticleGroupData::ID groupId = m_system->groupIds.value(str, QQuickParticleGroupData::InvalidID);
if (groupId == QQuickParticleGroupData::InvalidID) {
// invalid data, not finished setting up, or whatever. Fallback: do not cache.
m_groupIdsNeedRecalculation = true;
} else {
m_groupIds.append(groupId);
}
}
}
void QQuickParticlePainter::setSystem(QQuickParticleSystem *arg)
{
if (m_system != arg) {
m_system = arg;
m_groupIdsNeedRecalculation = true;
if (m_system){
m_system->registerParticlePainter(this);
reset();
}
emit systemChanged(arg);
}
}
void QQuickParticlePainter::setGroups(const QStringList &arg)
{
if (m_groups != arg) {
m_groups = arg;
m_groupIdsNeedRecalculation = true;
//Note: The system watches this as it has to recalc things when groups change. It will request a reset if necessary
Q_EMIT groupsChanged(arg);
}
}
void QQuickParticlePainter::load(QQuickParticleData* d)
{
initialize(d->groupId, d->index);
if (m_pleaseReset)
return;
m_pendingCommits << qMakePair(d->groupId, d->index);
}
void QQuickParticlePainter::reload(QQuickParticleData* d)
{
if (m_pleaseReset)
return;
m_pendingCommits << qMakePair(d->groupId, d->index);
}
void QQuickParticlePainter::reset()
{
m_pendingCommits.clear();
m_pleaseReset = true;
}
void QQuickParticlePainter::setCount(int c)//### TODO: some resizeing so that particles can reallocate on size change instead of recreate
{
Q_ASSERT(c >= 0); //XXX
if (c == m_count)
return;
m_count = c;
emit countChanged();
reset();
}
void QQuickParticlePainter::calcSystemOffset(bool resetPending)
{
if (!m_system || !parentItem())
return;
QPointF lastOffset = m_systemOffset;
m_systemOffset = -1 * this->mapFromItem(m_system, QPointF(0.0, 0.0));
if (lastOffset != m_systemOffset && !resetPending){
//Reload all particles//TODO: Necessary?
foreach (const QString &g, m_groups){
int gId = m_system->groupIds[g];
foreach (QQuickParticleData* d, m_system->groupData[gId]->data)
reload(d);
}
}
}
typedef QPair<int,int> intPair;
void QQuickParticlePainter::performPendingCommits()
{
calcSystemOffset();
foreach (intPair p, m_pendingCommits)
commit(p.first, p.second);
m_pendingCommits.clear();
}
QT_END_NAMESPACE
#include "moc_qquickparticlepainter_p.cpp"
|
