view_effect.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/canvas/canvas.hpp>
#include <algorithm>
#include <cmath>
#include <memory>
#include <string>
#include <vector>
 
namespace pulp::canvas {

class ViewEffect {
public:
    virtual ~ViewEffect() = default;

    virtual void configure_layer(Canvas& canvas, float x, float y, float w, float h) = 0;

    virtual int layer_count() const { return 1; }

    virtual bool needs_layer() const { return true; }

    virtual void paint_overlay(Canvas& canvas, float x, float y,
                               float w, float h) {
        (void)canvas; (void)x; (void)y; (void)w; (void)h;
    }
};

struct GpuBlurEffect : ViewEffect {
    float radius_x = 4.0f;
    float radius_y = 4.0f;
 
    void configure_layer(Canvas& canvas, float x, float y, float w, float h) override {
        canvas.save_layer(x, y, w, h, 1.0f, std::max(radius_x, radius_y));
    }
};

struct GpuBloomEffect : ViewEffect {
    float threshold = 0.8f;  
    float intensity = 0.5f;  
    float radius = 8.0f;     
 
    void configure_layer(Canvas& canvas, float x, float y, float w, float h) override {
        // Real bloom: SkiaCanvas thresholds + blurs + additively composites the
        // glow; other backends degrade to a plain blurred layer (base default).
        canvas.save_layer_with_bloom(x, y, w, h, intensity, threshold, radius);
    }
};

struct ChromaticAberrationEffect : ViewEffect {
    float offset = 2.0f;  
 
    void configure_layer(Canvas& canvas, float x, float y, float w, float h) override {
        Canvas::ShaderUniforms u;
        u.value = offset;  // per-channel offset (px), passed via `value`
        canvas.save_layer_with_sksl_post_effect(
            x, y, w, h,
            "uniform shader content;"
            "uniform float value;"
            "half4 main(float2 xy) {"
            "  return half4(content.eval(xy + float2(value, 0.0)).r,"
            "               content.eval(xy).g,"
            "               content.eval(xy - float2(value, 0.0)).b,"
            "               content.eval(xy).a);"
            "}",
            u, /*sample_radius=*/offset);
    }
};

struct VignetteEffect : ViewEffect {
    float intensity = 0.5f;     
    float radius = 0.75f;       
    Color edge_color = Color::rgba(0.0f, 0.0f, 0.0f, 0.5f);
 
    void configure_layer(Canvas& canvas, float x, float y, float w, float h) override {
        // Plain compositing layer; the darkening happens in paint_overlay().
        canvas.save_layer(x, y, w, h, 1.0f, 0.0f);
    }
 
    void paint_overlay(Canvas& canvas, float x, float y,
                       float w, float h) override {
        if (intensity <= 0.0f || w <= 0.0f || h <= 0.0f) return;
        const float cx = x + w * 0.5f;
        const float cy = y + h * 0.5f;
        const float outer = 0.5f * std::sqrt(w * w + h * h);  // center→corner
        const float inner = radius * std::min(w, h) * 0.5f;   // darkening start
        const float inner_frac =
            outer > 0.0f ? std::min(inner / outer, 0.99f) : 0.0f;
 
        const Color clear = Color::rgba(edge_color.r, edge_color.g,
                                        edge_color.b, 0.0f);
        const Color edge = Color::rgba(edge_color.r, edge_color.g, edge_color.b,
                                       edge_color.a * intensity);
        const Color colors[3] = {clear, clear, edge};
        const float positions[3] = {0.0f, inner_frac, 1.0f};
        canvas.set_fill_gradient_radial(cx, cy, outer, colors, positions, 3);
        canvas.fill_rect(x, y, w, h);
        canvas.clear_fill_gradient();
    }
};

struct SkslPostEffect : ViewEffect {
    std::string sksl;
    float value = 0.0f;   
    float time = 0.0f;    
    std::vector<Canvas::NamedUniform> uniforms;
    Canvas::BlendMode blend_mode = Canvas::BlendMode::normal;
    float sample_radius = 0.0f;
 
    void configure_layer(Canvas& canvas, float x, float y, float w, float h) override {
        Canvas::ShaderUniforms u;
        u.value = value;
        u.time = time;
        canvas.save_layer_with_sksl_post_effect(x, y, w, h, sksl, u,
                                                sample_radius, uniforms, blend_mode);
    }
};
 
// A `CustomShaderEffect` (arbitrary SkSL as a view post-effect) used to live
// here. It stored `sksl`, `value`, and `time` and then ignored all three —
// `configure_layer()` pushed a plain layer, so setting one had no visual effect
// whatsoever. Applying SkSL to already-rendered subtree content needs a
// child-shader compositor (Skia's runtime-shader image filter), which now
// exists as `Canvas::save_layer_with_sksl_post_effect` (the SkSL declares
// `uniform shader content`). A view post-effect can be built on it; note that
// this is distinct from `draw_with_sksl()`, which fills a fresh rect from a
// generative shader and cannot post-process. Widget body shaders — which do
// work — are `CustomShaderHost`.

class EffectChain : public ViewEffect {
public:
    void add(std::shared_ptr<ViewEffect> effect) {
        effects_.push_back(std::move(effect));
    }
 
    void configure_layer(Canvas& canvas, float x, float y, float w, float h) override {
        // Apply effects in order — each wraps the previous in a layer
        for (auto& effect : effects_) {
            effect->configure_layer(canvas, x, y, w, h);
        }
    }

    int layer_count() const override {
        int total = 0;
        for (const auto& effect : effects_) total += effect->layer_count();
        return total;
    }
 
    bool needs_layer() const override {
        return !effects_.empty();
    }

    void paint_overlay(Canvas& canvas, float x, float y,
                       float w, float h) override {
        for (auto& effect : effects_)
            effect->paint_overlay(canvas, x, y, w, h);
    }
 
    const std::vector<std::shared_ptr<ViewEffect>>& effects() const { return effects_; }
 
private:
    std::vector<std::shared_ptr<ViewEffect>> effects_;
};
 
} // namespace pulp::canvas