AnimationUniformExtension.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorAnimation/phosphoranimation_export.h>
 
#include <PhosphorShaders/BaseUniforms.h>
#include <PhosphorShaders/IUniformExtension.h>
 
#include <QMutex>
#include <QMutexLocker>
#include <QSizeF>
#include <QVector4D>
 
#include <atomic>
#include <cstring>
 
namespace PhosphorAnimation {
 
class PHOSPHORANIMATION_EXPORT AnimationUniformExtension : public PhosphorShaders::IUniformExtension
{
public:
    AnimationUniformExtension()
    {
        std::memset(&m_data, 0, sizeof(m_data));
        // iAnchorRectInTexture defaults to the (0, 0, 1, 1) identity —
        // a card-sized anchor with no capture margin. memset leaves it
        // (0, 0, 0, 0); a zero width/height would collapse every
        // surfaceColor sample to the texture's corner texel (and divide
        // animation.vert's remap by zero) before the first geometry
        // sync lands a real value.
        m_data.iAnchorRectInTexture[2] = 1.0f;
        m_data.iAnchorRectInTexture[3] = 1.0f;
    }
 
    int extensionSize() const override
    {
        return static_cast<int>(sizeof(m_data));
    }
 
    void write(char* buffer, int offset) const override
    {
        QMutexLocker lock(&m_mutex);
        std::memcpy(buffer + offset, &m_data, sizeof(m_data));
    }
 
    bool isDirty() const override
    {
        return m_dirty.load(std::memory_order_acquire);
    }
 
    void clearDirty() override
    {
        m_dirty.store(false, std::memory_order_release);
    }
 
    bool requiresPhysicalResolution() const override
    {
        return false;
    }
 
    void setISurfaceScreenPos(const QVector4D& pos)
    {
        QMutexLocker lock(&m_mutex);
        if (m_data.iSurfaceScreenPos[0] == pos.x() && m_data.iSurfaceScreenPos[1] == pos.y()
            && m_data.iSurfaceScreenPos[2] == pos.z() && m_data.iSurfaceScreenPos[3] == pos.w()) {
            return;
        }
        m_data.iSurfaceScreenPos[0] = static_cast<float>(pos.x());
        m_data.iSurfaceScreenPos[1] = static_cast<float>(pos.y());
        m_data.iSurfaceScreenPos[2] = static_cast<float>(pos.z());
        m_data.iSurfaceScreenPos[3] = static_cast<float>(pos.w());
        m_dirty.store(true, std::memory_order_release);
    }
 
    void setIAnchorSize(const QSizeF& size)
    {
        QMutexLocker lock(&m_mutex);
        const float w = static_cast<float>(size.width());
        const float h = static_cast<float>(size.height());
        if (m_data.iAnchorSize[0] == w && m_data.iAnchorSize[1] == h) {
            return;
        }
        m_data.iAnchorSize[0] = w;
        m_data.iAnchorSize[1] = h;
        m_dirty.store(true, std::memory_order_release);
    }
 
    void setIAnchorPosInFbo(const QPointF& pos)
    {
        QMutexLocker lock(&m_mutex);
        const float x = static_cast<float>(pos.x());
        const float y = static_cast<float>(pos.y());
        if (m_data.iAnchorPosInFbo[0] == x && m_data.iAnchorPosInFbo[1] == y) {
            return;
        }
        m_data.iAnchorPosInFbo[0] = x;
        m_data.iAnchorPosInFbo[1] = y;
        m_dirty.store(true, std::memory_order_release);
    }
 
    void setIAnchorRectInTexture(const QVector4D& rect)
    {
        QMutexLocker lock(&m_mutex);
        if (m_data.iAnchorRectInTexture[0] == rect.x() && m_data.iAnchorRectInTexture[1] == rect.y()
            && m_data.iAnchorRectInTexture[2] == rect.z() && m_data.iAnchorRectInTexture[3] == rect.w()) {
            return;
        }
        m_data.iAnchorRectInTexture[0] = static_cast<float>(rect.x());
        m_data.iAnchorRectInTexture[1] = static_cast<float>(rect.y());
        m_data.iAnchorRectInTexture[2] = static_cast<float>(rect.z());
        m_data.iAnchorRectInTexture[3] = static_cast<float>(rect.w());
        m_dirty.store(true, std::memory_order_release);
    }
 
private:
    struct alignas(16) AnimationExtensionData
    {
        float iSurfaceScreenPos[4]; // offset 0  (16 bytes), UBO offset 672 = 0 + sizeof(BaseUniforms)
        float iAnchorSize[2]; // offset 16 (8 bytes),  UBO offset 688
        float iAnchorPosInFbo[2]; // offset 24 (8 bytes),  UBO offset 696. Anchor's top-left
                                  //   position inside the shader item's FBO, in logical pixels.
                                  //   See setIAnchorPosInFbo's docstring for the per-extent math
                                  //   contract this enables.
        float iAnchorRectInTexture[4]; // offset 32 (16 bytes), UBO offset 704. Card's UV sub-rect
                                       //   within uTexture0. offset 32 is already 16-aligned, so
                                       //   std140 inserts no pad before it. See
                                       //   setIAnchorRectInTexture's docstring.
    };
    static_assert(sizeof(AnimationExtensionData) == 48,
                  "AnimationExtensionData must be exactly 48 bytes — std140 vec4-aligned, no trailing pad");
    static_assert(sizeof(PhosphorShaders::BaseUniforms) + sizeof(AnimationExtensionData) == 720,
                  "BaseUniforms + AnimationExtensionData must total 720 bytes — matches the trailing-field "
                  "layout declared in data/animations/shared/animation_uniforms.glsl");
    static_assert(sizeof(PhosphorShaders::BaseUniforms) == 672,
                  "BaseUniforms must remain at 672 bytes — growing it shifts ZoneUniformExtension's "
                  "zoneRects offset and breaks every zone shader compiled against `data/shaders/shared/"
                  "common.glsl`. AnimationUniformExtension exists precisely to avoid that growth.");
 
    AnimationExtensionData m_data;
    mutable QMutex m_mutex;
    std::atomic<bool> m_dirty{true};
};
 
} // namespace PhosphorAnimation