renderer/image: add interruptible transition rendering with custom shaders

Adds an animated wallpaper transition path to CImageElement: a two-texture
blend (start -> end) driven by fadeLayersIn/Out durations, with an optional
custom GLSL fragment shader supplied by path.

- CImageElement::transitionTo captures the in-flight blend to an FBO when a
  transition is interrupted mid-way, using that as the new start texture so a
  fresh transition can begin to the new target (no flicker, no black flash).
- IRenderer gains renderTransition / captureTransitionState / ensureTransitionShader.
  Custom shaders are stat()-checked once at transition start and recompiled only
  on mtime change; the per-frame render path is a single cache lookup + draw,
  with no filesystem or compile work.
- CFramebuffer sets m_tex->m_size after glTexImage2D so captured textures report
  the right size to the shader's tex1Size/tex2Size uniforms.
- A captured texture keeps its owning CFramebuffer alive via m_tempFramebuffer.
- All fit modes (stretch/cover/contain/tile) are honoured; the host pushes the
  config duration to u_duration each frame (GLES cannot initialize uniforms).

Author: markg85

include/hyprtoolkit/element/Image.hpp

@@ -48,6 +48,17 @@ namespace Hyprtoolkit {
         Hyprutils::Memory::CSharedPointer<CImageBuilder> rebuild();
         virtual Hyprutils::Math::Vector2D                size();
 
+        void transitionTo(const std::string& path,
+                          eImageFitMode fitMode,
+                          float durationOut,
+                          float durationIn,
+                          const std::string& shaderPath = "");
+
+        bool isTransitioning() const;
+
+        float getTransitionProgressOut() const;
+        float getTransitionProgressIn() const;
+
       private:
         CImageElement(const SImageData& data);
         static Hyprutils::Memory::CSharedPointer<CImageElement> create(const SImageData& data);
@@ -64,6 +75,8 @@ namespace Hyprtoolkit {
 
         void                                             renderTex();
 
+        void                                             renderTransition();
+
         Hyprutils::Memory::CUniquePointer<SImageImpl>    m_impl;
 
         friend class CImageBuilder;

src/element/image/Image.cpp

@@ -7,6 +7,7 @@
 #include "../../system/Icons.hpp"
 #include "../../resource/assetCache/AssetCache.hpp"
 #include "../../renderer/RendererTexture.hpp"
+#include <random>
 
 #include "../Element.hpp"
 
@@ -27,6 +28,11 @@ void CImageElement::paint() {
     if (m_impl->failed)
         return;
 
+    if (m_impl->transition.active) {
+        renderTransition();
+        return;
+    }
+
     auto assetToUse = m_impl->cacheEntry;
 
     if (!assetToUse || !assetToUse->tex())
@@ -244,3 +250,130 @@ Vector2D SImageImpl::preferredSvgSize() {
 
     return Vector2D{max * lastScale, max * lastScale}.round();
 }
+
+void CImageElement::transitionTo(const std::string& path,
+                                  eImageFitMode fitMode,
+                                  float durationOut,
+                                  float durationIn,
+                                  const std::string& shaderPath) {
+    if (m_impl->transition.active) {
+        // Capture the in-flight blend to an FBO and use it as the new start texture.
+        if (m_impl->transition.startTexture && m_impl->transition.endTexture) {
+            IRenderer::STransitionRenderData captureData = {
+                .box = impl->position,
+                .startTexture = m_impl->transition.startTexture,
+                .endTexture = m_impl->transition.endTexture,
+                .progress = m_impl->transition.progress,
+                .a = 1.F,
+                .fitMode = m_impl->data.fitMode,
+                .shaderPath = m_impl->transition.shaderPath,
+                .randomPixel = m_impl->transition.randomPixel,
+                .duration = m_impl->transition.duration,
+            };
+
+            auto capturedTex = g_renderer->captureTransitionState(captureData);
+            if (capturedTex)
+                m_impl->transition.startTexture = capturedTex;
+        }
+    } else if (m_impl->cacheEntry && m_impl->cacheEntry->tex()) {
+        m_impl->transition.startTexture = m_impl->cacheEntry->tex();
+    }
+
+    m_impl->transition.active     = true;
+    m_impl->transition.progress   = 0.0f;
+    m_impl->transition.shaderPath = shaderPath;
+    m_impl->transition.startTime  = std::chrono::steady_clock::now();
+
+    m_impl->transition.randomPixel = Hyprutils::Math::Vector2D(
+        static_cast<float>(rand() % 1000) / 1000.0f,
+        static_cast<float>(rand() % 1000) / 1000.0f
+    );
+
+    // GLES cannot initialize uniform values, so u_duration is pushed to the shader
+    // each frame; a shader may further remap progress via a local const.
+    m_impl->transition.duration = std::max(durationOut, durationIn);
+
+    // Stat the shader file once here so renderTransition can reuse the cached
+    // program per-frame without touching the filesystem.
+    g_renderer->ensureTransitionShader(shaderPath);
+
+    // Populated once the new asset finishes loading.
+    m_impl->transition.endTexture.reset();
+
+    m_impl->data.path     = path;
+    m_impl->data.fitMode = fitMode;
+    renderTex();
+
+    if (impl->window)
+        impl->window->scheduleReposition(impl->self.lock());
+}
+
+bool CImageElement::isTransitioning() const {
+    return m_impl->transition.active;
+}
+
+float CImageElement::getTransitionProgressOut() const {
+    return m_impl->transition.progress;
+}
+
+float CImageElement::getTransitionProgressIn() const {
+    return m_impl->transition.progress;
+}
+
+void CImageElement::renderTransition() {
+    auto& trans = m_impl->transition;
+
+    auto  now     = std::chrono::steady_clock::now();
+    float elapsed = std::chrono::duration<float>(now - trans.startTime).count();
+    trans.progress = std::clamp(elapsed / trans.duration, 0.0f, 1.0f);
+
+    if (trans.progress >= 1.0f) {
+        trans.active = false;
+        trans.startTexture.reset();
+        trans.endTexture.reset();
+
+        if (m_impl->cacheEntry && m_impl->cacheEntry->tex()) {
+            g_renderer->renderTexture({
+                .box = impl->position,
+                .texture = m_impl->cacheEntry->tex(),
+                .a = 1.F,
+                .rounding = 0,
+            });
+        }
+        return;
+    }
+
+    // The end texture is resolved once the new asset finishes loading.
+    SP<IRendererTexture> endTex;
+    if (m_impl->cacheEntry && m_impl->cacheEntry->tex()) {
+        endTex = m_impl->cacheEntry->tex();
+        trans.endTexture = endTex;
+    } else
+        endTex = trans.endTexture;
+
+    if (trans.startTexture && endTex) {
+        g_renderer->renderTransition({
+            .box = impl->position,
+            .startTexture = trans.startTexture,
+            .endTexture = endTex,
+            .progress = trans.progress,
+            .a = 1.F,
+            .rounding = 0,
+            .fitMode = m_impl->data.fitMode,
+            .shaderPath = trans.shaderPath,
+            .randomPixel = trans.randomPixel,
+            .duration = trans.duration,
+        });
+    } else if (trans.startTexture) {
+        // End texture not loaded yet, keep showing the start.
+        g_renderer->renderTexture({
+            .box = impl->position,
+            .texture = trans.startTexture,
+            .a = 1.F,
+            .rounding = 0,
+        });
+    }
+
+    if (impl->window)
+        impl->window->scheduleReposition(impl->self.lock());
+}

src/element/image/Image.hpp

@@ -40,5 +40,17 @@ namespace Hyprtoolkit {
         struct {
             Hyprutils::Signal::CHyprSignalListener cacheEntryDone;
         } listeners;
+
+        struct {
+            bool                                    active = false;
+            float                                   progress = 0.0f;
+            float                                   duration = 1.0f;
+            std::string                             shaderPath;
+            std::chrono::steady_clock::time_point   startTime;
+            Hyprutils::Math::Vector2D               randomPixel;
+
+            Hyprutils::Memory::CSharedPointer<IRendererTexture> startTexture;
+            Hyprutils::Memory::CSharedPointer<IRendererTexture> endTexture;
+        } transition;
     };
 }

src/renderer/Renderer.hpp

@@ -18,6 +18,7 @@ namespace Hyprtoolkit {
     class IToolkitWindow;
     class IRendererTexture;
     class CSyncTimeline;
+    class CFramebuffer;
 
     class IRenderer {
       public:
@@ -62,14 +63,31 @@ namespace Hyprtoolkit {
             int                         thick = 2;
         };
 
+        struct STransitionRenderData {
+            CBox                                 box;
+            SP<IRendererTexture>                 startTexture;
+            SP<IRendererTexture>                 endTexture;
+            float                                progress = 0.0f;
+            float                                a = 1.F;
+            int                                  rounding = 0;
+            eImageFitMode                        fitMode = IMAGE_FIT_MODE_COVER;
+            std::string                          shaderPath;
+            Vector2D                             randomPixel;
+            float                                duration = 0.0f;  // passed to shader via u_duration
+        };
+
         virtual void                 beginRendering(SP<IToolkitWindow> window, SP<Aquamarine::IBuffer> buf) = 0;
         virtual void                 render(bool ignoreSync = false)                                        = 0;
         virtual void                 endRendering()                                                         = 0;
         virtual void                 renderRectangle(const SRectangleRenderData& data)                      = 0;
         virtual SP<IRendererTexture> uploadTexture(const STextureData& data)                                = 0;
         virtual void                 renderTexture(const STextureRenderData& data)                          = 0;
+        virtual void                 renderTransition(const STransitionRenderData& data)                      = 0;
         virtual void                 renderBorder(const SBorderRenderData& data)                            = 0;
         virtual void                 renderPolygon(const SPolygonRenderData& data)                          = 0;
+        virtual SP<IRendererTexture> captureTransitionState(const STransitionRenderData& data)                = 0;
+        // Stat the shader file once and recompile only when its mtime changed.
+        virtual void                 ensureTransitionShader(const std::string& path)                         = 0;
         virtual void                 renderLine(const SLineRenderData& data)                                = 0;
         virtual void                 signalRenderPoint(SP<CSyncTimeline> timeline)                          = 0;
 

src/renderer/gl/Framebuffer.cpp

@@ -47,6 +47,7 @@ bool CFramebuffer::alloc(int w, int h, uint32_t drmFormat) {
     if (firstAlloc || m_size != Vector2D(w, h)) {
         m_tex->bind();
         glTexImage2D(GL_TEXTURE_2D, 0, glFormat, w, h, 0, GL_RGBA, glType, nullptr);
+        m_tex->m_size = Vector2D(w, h);
         glBindFramebuffer(GL_FRAMEBUFFER, m_fb);
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tex->m_texID, 0);
 

src/renderer/gl/GLTexture.hpp

@@ -11,6 +11,8 @@
 #include "../../helpers/Memory.hpp"
 
 namespace Hyprtoolkit {
+    class CFramebuffer;
+
     enum eGLTextureType : uint8_t {
         TEXTURE_INVALID,  // Invalid
         TEXTURE_RGBA,     // 4 channels
@@ -46,6 +48,9 @@ namespace Hyprtoolkit {
 
         ASP<Hyprgraphics::IAsyncResource> m_resource;
 
+        // Keeps the owning FBO alive when this texture was produced by captureTransitionState.
+        SP<CFramebuffer>                  m_tempFramebuffer;
+
         void                              upload();
         void                              allocate();
         void                              bind();