Phosphor
Qt6 / Wayland library suite for window-management tools
Loading...
Searching...
No Matches
AnimationUniformExtension.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: 2026 fuddlesworth
2// SPDX-License-Identifier: LGPL-2.1-or-later
3
4#pragma once
5
6#include <PhosphorAnimation/phosphoranimation_export.h>
7
10
11#include <QMutex>
12#include <QMutexLocker>
13#include <QPointF>
14#include <QSizeF>
15#include <QVector>
16#include <QVector2D>
17#include <QVector4D>
18
19#include <atomic>
20#include <cstring>
21
22namespace PhosphorAnimation {
23
77{
78public:
80 {
81 std::memset(&m_data, 0, sizeof(m_data));
82 // iAnchorRectInTexture defaults to the (0, 0, 1, 1) identity —
83 // a card-sized anchor with no capture margin. memset leaves it
84 // (0, 0, 0, 0); a zero width/height would collapse every
85 // surfaceColor sample to the texture's corner texel (and divide
86 // animation.vert's remap by zero) before the first geometry
87 // sync lands a real value.
88 m_data.iAnchorRectInTexture[2] = 1.0f;
89 m_data.iAnchorRectInTexture[3] = 1.0f;
90 }
91
92 int extensionSize() const override
93 {
94 return static_cast<int>(sizeof(m_data));
95 }
96
97 void write(char* buffer, int offset) const override
98 {
99 QMutexLocker lock(&m_mutex);
100 std::memcpy(buffer + offset, &m_data, sizeof(m_data));
101 }
102
103 bool isDirty() const override
104 {
105 return m_dirty.load(std::memory_order_acquire);
106 }
107
108 void clearDirty() override
109 {
110 m_dirty.store(false, std::memory_order_release);
111 }
112
122 bool requiresPhysicalResolution() const override
123 {
124 return false;
125 }
126
140 void setISurfaceScreenPos(const QVector4D& pos)
141 {
142 QMutexLocker lock(&m_mutex);
143 if (m_data.iSurfaceScreenPos[0] == pos.x() && m_data.iSurfaceScreenPos[1] == pos.y()
144 && m_data.iSurfaceScreenPos[2] == pos.z() && m_data.iSurfaceScreenPos[3] == pos.w()) {
145 return;
146 }
147 m_data.iSurfaceScreenPos[0] = static_cast<float>(pos.x());
148 m_data.iSurfaceScreenPos[1] = static_cast<float>(pos.y());
149 m_data.iSurfaceScreenPos[2] = static_cast<float>(pos.z());
150 m_data.iSurfaceScreenPos[3] = static_cast<float>(pos.w());
151 m_dirty.store(true, std::memory_order_release);
152 }
153
166 void setIAnchorSize(const QSizeF& size)
167 {
168 QMutexLocker lock(&m_mutex);
169 const float w = static_cast<float>(size.width());
170 const float h = static_cast<float>(size.height());
171 if (m_data.iAnchorSize[0] == w && m_data.iAnchorSize[1] == h) {
172 return;
173 }
174 m_data.iAnchorSize[0] = w;
175 m_data.iAnchorSize[1] = h;
176 m_dirty.store(true, std::memory_order_release);
177 }
178
203 void setIAnchorPosInFbo(const QPointF& pos)
204 {
205 QMutexLocker lock(&m_mutex);
206 const float x = static_cast<float>(pos.x());
207 const float y = static_cast<float>(pos.y());
208 if (m_data.iAnchorPosInFbo[0] == x && m_data.iAnchorPosInFbo[1] == y) {
209 return;
210 }
211 m_data.iAnchorPosInFbo[0] = x;
212 m_data.iAnchorPosInFbo[1] = y;
213 m_dirty.store(true, std::memory_order_release);
214 }
215
226 void setISwitchDelta(const QVector4D& v)
227 {
228 setVec4(m_data.iSwitchDelta, v);
229 }
230 void setIStripMotion(const QVector4D& v)
231 {
232 setVec4(m_data.iStripMotion, v);
233 }
234 void setIStripRect(const QVector4D& v)
235 {
236 setVec4(m_data.iStripRect, v);
237 }
238 void setIFromRect(const QVector4D& v)
239 {
240 setVec4(m_data.iFromRect, v);
241 }
242 void setIToRect(const QVector4D& v)
243 {
244 setVec4(m_data.iToRect, v);
245 }
246 void setIStripAxis(const QVector2D& v)
247 {
248 QMutexLocker lock(&m_mutex);
249 if (m_data.iStripAxis[0] == v.x() && m_data.iStripAxis[1] == v.y()) {
250 return;
251 }
252 m_data.iStripAxis[0] = v.x();
253 m_data.iStripAxis[1] = v.y();
254 m_dirty.store(true, std::memory_order_release);
255 }
257 {
258 QMutexLocker lock(&m_mutex);
259 if (m_data.iOldWindowOpacity == v) {
260 return;
261 }
262 m_data.iOldWindowOpacity = v;
263 m_dirty.store(true, std::memory_order_release);
264 }
265 void setIHasOldWindow(bool has)
266 {
267 QMutexLocker lock(&m_mutex);
268 const int v = has ? 1 : 0;
269 if (m_data.iHasOldWindow == v) {
270 return;
271 }
272 m_data.iHasOldWindow = v;
273 m_dirty.store(true, std::memory_order_release);
274 }
275
279 void setIIconRect(const QVector4D& rect)
280 {
281 setVec4(m_data.iIconRect, rect);
282 }
283
287 void setIMoveTrail(const QVector<QVector2D>& trail)
288 {
289 QMutexLocker lock(&m_mutex);
290 bool changed = false;
291 for (int i = 0; i < 16; ++i) {
292 const float x = i < trail.size() ? trail[i].x() : 0.0f;
293 const float y = i < trail.size() ? trail[i].y() : 0.0f;
294 if (m_data.iMoveTrail[i][0] != x || m_data.iMoveTrail[i][1] != y) {
295 m_data.iMoveTrail[i][0] = x;
296 m_data.iMoveTrail[i][1] = y;
297 changed = true;
298 }
299 }
300 if (changed) {
301 m_dirty.store(true, std::memory_order_release);
302 }
303 }
304
307 void setIMoveMesh(const QVector<QVector2D>& mesh)
308 {
309 QMutexLocker lock(&m_mutex);
310 bool changed = false;
311 for (int i = 0; i < 16; ++i) {
312 const float x = i < mesh.size() ? mesh[i].x() : 0.0f;
313 const float y = i < mesh.size() ? mesh[i].y() : 0.0f;
314 if (m_data.iMoveMesh[i][0] != x || m_data.iMoveMesh[i][1] != y) {
315 m_data.iMoveMesh[i][0] = x;
316 m_data.iMoveMesh[i][1] = y;
317 changed = true;
318 }
319 }
320 if (changed) {
321 m_dirty.store(true, std::memory_order_release);
322 }
323 }
324
339 void setIAnchorRectInTexture(const QVector4D& rect)
340 {
341 QMutexLocker lock(&m_mutex);
342 if (m_data.iAnchorRectInTexture[0] == rect.x() && m_data.iAnchorRectInTexture[1] == rect.y()
343 && m_data.iAnchorRectInTexture[2] == rect.z() && m_data.iAnchorRectInTexture[3] == rect.w()) {
344 return;
345 }
346 m_data.iAnchorRectInTexture[0] = static_cast<float>(rect.x());
347 m_data.iAnchorRectInTexture[1] = static_cast<float>(rect.y());
348 m_data.iAnchorRectInTexture[2] = static_cast<float>(rect.z());
349 m_data.iAnchorRectInTexture[3] = static_cast<float>(rect.w());
350 m_dirty.store(true, std::memory_order_release);
351 }
352
353private:
356 void setVec4(float (&dst)[4], const QVector4D& v)
357 {
358 QMutexLocker lock(&m_mutex);
359 if (dst[0] == v.x() && dst[1] == v.y() && dst[2] == v.z() && dst[3] == v.w()) {
360 return;
361 }
362 dst[0] = v.x();
363 dst[1] = v.y();
364 dst[2] = v.z();
365 dst[3] = v.w();
366 m_dirty.store(true, std::memory_order_release);
367 }
368
376 struct alignas(16) AnimationExtensionData
377 {
378 float iSurfaceScreenPos[4]; // offset 0 (16 bytes), UBO offset 672 = 0 + sizeof(BaseUniforms)
379 float iAnchorSize[2]; // offset 16 (8 bytes), UBO offset 688
380 float iAnchorPosInFbo[2]; // offset 24 (8 bytes), UBO offset 696. Anchor's top-left
381 // position inside the shader item's FBO, in logical pixels.
382 // See setIAnchorPosInFbo's docstring for the per-extent math
383 // contract this enables.
384 float iAnchorRectInTexture[4]; // offset 32 (16 bytes), UBO offset 704. Card's UV sub-rect
385 // within uTexture0. offset 32 is already 16-aligned, so
386 // std140 inserts no pad before it. See
387 // setIAnchorRectInTexture's docstring.
388 // ── Transition-class tail (see the setter block's doc) ──────────
389 float iSwitchDelta[4]; // offset 48 (16 bytes), UBO offset 720
390 float iStripMotion[4]; // offset 64 (16 bytes), UBO offset 736
391 float iStripRect[4]; // offset 80 (16 bytes), UBO offset 752
392 float iFromRect[4]; // offset 96 (16 bytes), UBO offset 768
393 float iToRect[4]; // offset 112 (16 bytes), UBO offset 784
394 float iStripAxis[2]; // offset 128 (8 bytes), UBO offset 800
395 float iOldWindowOpacity; // offset 136 (4 bytes), UBO offset 808
396 int iHasOldWindow; // offset 140 (4 bytes), UBO offset 812. The UBO
397 // branch's mirror of the kwin default-block
398 // uniform of the same name (oldColor()'s
399 // snapshot gate).
400 float iIconRect[4]; // offset 144 (16 bytes), UBO offset 816 — see
401 // setIIconRect.
402 float iMoveTrail[16][4]; // offset 160 (256 bytes), UBO offset 832.
403 // std140 gives a vec2 array a 16-byte
404 // element stride, so each entry is
405 // (x, y, pad, pad); see setIMoveTrail.
406 float iMoveMesh[16][4]; // offset 416 (256 bytes), UBO offset 1088.
407 // Same stride story; see setIMoveMesh.
408 };
409 static_assert(sizeof(AnimationExtensionData) == 672,
410 "AnimationExtensionData must be exactly 672 bytes — std140 vec4-aligned, no trailing pad");
411 static_assert(sizeof(PhosphorShaders::BaseUniforms) + sizeof(AnimationExtensionData) == 1344,
412 "BaseUniforms + AnimationExtensionData must total 1344 bytes — matches the trailing-field "
413 "layout declared in data/animations/shared/animation_uniforms.glsl");
414 static_assert(sizeof(PhosphorShaders::BaseUniforms) == 672,
415 "BaseUniforms must remain at 672 bytes — growing it shifts ZoneUniformExtension's "
416 "zoneRects offset and breaks every zone shader compiled against `data/overlays/shared/"
417 "common.glsl`. AnimationUniformExtension exists precisely to avoid that growth.");
418
419 AnimationExtensionData m_data;
420 mutable QMutex m_mutex;
421 std::atomic<bool> m_dirty{true};
422};
423
424} // namespace PhosphorAnimation
void setIAnchorPosInFbo(const QPointF &pos)
Anchor's top-left position inside the shader item's FBO, in logical pixels.
Definition AnimationUniformExtension.h:203
void setIMoveMesh(const QVector< QVector2D > &mesh)
Wobble lattice (the kwin path's iMoveMesh): 16 per-node deflections from the node's ideal grid spot o...
Definition AnimationUniformExtension.h:307
void setIOldWindowOpacity(float v)
Definition AnimationUniformExtension.h:256
int extensionSize() const override
Size in bytes of the extension region (must respect std140 alignment).
Definition AnimationUniformExtension.h:92
void clearDirty() override
Mark as clean after a successful write.
Definition AnimationUniformExtension.h:108
void setIStripMotion(const QVector4D &v)
Definition AnimationUniformExtension.h:230
AnimationUniformExtension()
Definition AnimationUniformExtension.h:79
bool requiresPhysicalResolution() const override
Animation shaders pair iResolution with logical-pixel extension fields (iAnchorSize,...
Definition AnimationUniformExtension.h:122
void setIStripRect(const QVector4D &v)
Definition AnimationUniformExtension.h:234
void setISurfaceScreenPos(const QVector4D &pos)
Surface origin in logical screen pixels (.xy) plus host screen dimensions (.zw).
Definition AnimationUniformExtension.h:140
void write(char *buffer, int offset) const override
Write extension data into buffer starting at offset.
Definition AnimationUniformExtension.h:97
bool isDirty() const override
Whether the extension data has changed since the last write.
Definition AnimationUniformExtension.h:103
void setIMoveTrail(const QVector< QVector2D > &trail)
Move-trail ring (the kwin path's iMoveTrail): up to 16 offsets of past window origins RELATIVE to the...
Definition AnimationUniformExtension.h:287
void setIAnchorSize(const QSizeF &size)
Anchor (card) pixel size in logical pixels.
Definition AnimationUniformExtension.h:166
void setISwitchDelta(const QVector4D &v)
Transition-class fields (bytes 48..143 of the extension, UBO offsets 720..815).
Definition AnimationUniformExtension.h:226
void setIAnchorRectInTexture(const QVector4D &rect)
Card's UV sub-rect within uTexture0, as (x, y, width, height) in the captured texture's [0,...
Definition AnimationUniformExtension.h:339
void setIStripAxis(const QVector2D &v)
Definition AnimationUniformExtension.h:246
void setIIconRect(const QVector4D &rect)
Minimize target (the kwin path's iIconRect): x/y/w/h in the same space as iSurfaceScreenPos.
Definition AnimationUniformExtension.h:279
void setIHasOldWindow(bool has)
Definition AnimationUniformExtension.h:265
void setIToRect(const QVector4D &v)
Definition AnimationUniformExtension.h:242
void setIFromRect(const QVector4D &v)
Definition AnimationUniformExtension.h:238
Interface for appending custom uniform data after the base UBO layout.
Definition IUniformExtension.h:18
Definition AnimatedValue.h:32