canvas_widget.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/view/view.hpp>
#include <pulp/canvas/canvas.hpp>
#include <algorithm>
#include <cmath>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace pulp::view {

struct NativeCanvasPaintContext {
    canvas::Canvas& canvas;
    Rect local_bounds;
    float backing_scale = 1.0f;
    std::uint64_t frame_id = 0;
    canvas::RendererBackend backend = canvas::RendererBackend::unknown;
};

class NativeCanvasPainter {
public:
    virtual ~NativeCanvasPainter() = default;
    virtual void paint(const NativeCanvasPaintContext& context) = 0;
};
 
enum class NativeCanvasBackendRequirement {
    any,
    skia_dawn_allow_recording,
    skia_dawn,
};

struct CanvasDrawCmd {
    enum class Type {
        // Shapes
        fill_rect, stroke_rect, fill_rounded_rect, stroke_rounded_rect,
        fill_circle, stroke_circle,
        stroke_line, stroke_arc,
        // Text
        fill_text, set_font, set_text_align, set_text_baseline,
        // Canvas2D `strokeText(text, x, y, maxWidth)` recorded
        // as a distinct cmd so the paint loop can route it through the
        // dedicated `Canvas::stroke_text` (true outlined glyphs) instead
        // of the older fillText-with-stroke-color approximation.
        // Layout: text in `text`, (x,y) in `x`/`y`, maxWidth in `w`
        // (0 = no limit), font size in `extra`, color in `color`.
        stroke_text,
        // Canvas2D `ctx.font` full CSS font shorthand. The
        // legacy `set_font` only carries family + size; the JS shim now
        // parses `[<style>] [<variant>] [<weight>] <size>[/<lineHeight>]
        // <family>`. `set_font_full` carries the parsed weight / slant
        // through to `Canvas::set_font_full`, which Skia honours via
        // `make_font(family, size, weight, slant)`. CG falls back to
        // family+size (no slant override) — same as the base
        // `set_font_full` default. Layout in CanvasDrawCmd:
        //   text  = family
        //   extra = size (px)
        //   x     = weight (100..900, cast to int)
        //   y     = slant (0=upright, 1=italic/oblique)
        //   x2    = letter_spacing in px (0 when derived from `font`)
        set_font_full,
        // Style
        set_fill_color, set_stroke_color, set_line_width,
        set_line_cap, set_line_join,
        set_global_alpha, set_blend_mode,
        // Gradient
        set_fill_gradient_linear, set_fill_gradient_radial, clear_fill_gradient,
        set_fill_gradient_radial_two_circles,
        // Canvas2D ctx.createConicGradient.
        // cx/cy in (x, y), start_angle in `extra`, stops in
        // gradient_colors / gradient_positions (same shape as the
        // linear / radial entries above).
        set_fill_gradient_conic,
        // Canvas2D `ctx.strokeStyle =
        // createLinearGradient(...) | createRadialGradient(...) |
        // createConicGradient(...)`. Field layout matches the fill
        // counterparts:
        //   set_stroke_gradient_linear:        x/y/x2/y2 = (x0,y0,x1,y1)
        //   set_stroke_gradient_radial:        x/y/extra = (cx,cy,radius)
        //   set_stroke_gradient_radial_two_circles:
        //                                      x/y/extra = (x0,y0,r0)
        //                                      x2/y2/w   = (x1,y1,r1)
        //   set_stroke_gradient_conic:         x/y/extra = (cx,cy,startAngle)
        // Stops live in gradient_colors / gradient_positions.
        set_stroke_gradient_linear,
        set_stroke_gradient_radial,
        set_stroke_gradient_radial_two_circles,
        set_stroke_gradient_conic,
        clear_stroke_gradient,
        // Canvas2D ctx.createPattern.
        // Image source path / data URI in `text`, tile modes packed into
        // `int_val` (bit 0 = x, bit 1 = y; 0 = repeat, 1 = no-repeat).
        // Fill patterns route through the backend pattern implementation;
        // stroke patterns fall back to solid stroke color on backends that
        // do not support stroke-pattern shaders.
        set_fill_pattern, set_stroke_pattern,
        // Path
        begin_path, move_to, line_to, quad_to, cubic_to, close_path,
        fill_path, stroke_path, clip_path,
        // Native arc subpaths.
        // Layout in CanvasDrawCmd:
        //   path_arc:        x=cx, y=cy, extra=radius,
        //                    x2=startAngle, y2=endAngle,
        //                    int_val=anticlockwise (0/1)
        //   path_arc_to:     x=x1, y=y1, x2=x2, y2=y2, extra=radius
        //   path_ellipse:    x=cx, y=cy, w=rx, h=ry, extra=rotation,
        //                    x2=startAngle, y2=endAngle,
        //                    int_val=anticlockwise (0/1)
        //   path_round_rect: x=x, y=y, w=w, h=h,
        //                    gradient_positions packed [tl_x,tl_y,
        //                    tr_x,tr_y, br_x,br_y, bl_x,bl_y]
        path_arc,
        path_arc_to,
        path_ellipse,
        path_round_rect,
        // State
        save, restore,
        // Transform
        translate, scale, rotate, clip_rect,
        set_transform,             // replace transform with affine matrix
        clip,                      // intersect clip with current path
        // Image
        draw_image,
        // SDF shader draw. `text` stores the geometry JSON and
        // `shader_sksl` stores optional structured SkSL.
        draw_sdf,
        // Canvas2D API coverage
        set_line_dash,             
        put_image_data,            
        // Canvas2D shadow* sticky state setters
        set_shadow_color,          
        set_shadow_blur,           
        set_shadow_offset_x,       
        set_shadow_offset_y,       
        // ctx.miterLimit and
        // ctx.imageSmoothingEnabled / Quality. Sticky state pushed by
        // the JS shim before the next stroke / drawImage.
        set_miter_limit,           
        set_image_smoothing,       
        // Canvas2D ctx.direction / ctx.filter sticky state.
        // direction enum (0=ltr, 1=rtl, 2=inherit) in `int_val`; filter
        // raw CSS <filter-function-list> string in `text`. Pushed by
        // the JS shim before fillText / strokeText / fill / stroke /
        // drawImage so the backend can wrap the next paint.
        set_direction,
        set_filter,
        // Clear
        clear, clear_rect,
        // Cached group: replays the commands stored under the key in `text`
        // inside an implicit save/restore, under the transform in effect at
        // this point of the stream (see CanvasWidget::end_group).
        replay_group
    };
    Type type = Type::clear;
    float x = 0, y = 0, w = 0, h = 0;
    float x2 = 0, y2 = 0;      // extra coords (line end, control point 1)
    float x3 = 0, y3 = 0;      // cubic control point 2
    canvas::Color color{255, 255, 255, 255};
    float extra = 0;            // radius, line width, font size, angle
    std::string text;           // for fill_text, set_font family
    std::string shader_sksl;
    std::vector<canvas::Canvas::NamedUniform> shader_uniforms;
    std::optional<canvas::Canvas::ShaderGeometry> shader_geometry;
    int int_val = 0;            // for enum values (text align, baseline, blend mode, cap, join)
    std::vector<canvas::Color> gradient_colors;    // for gradient stops
    std::vector<float> gradient_positions;          // gradient stop positions
    bool use_active_style = false;

    bool has_source_rect = false;
};

class CanvasWidget : public View {
private:
    struct RecordedCommands;
    struct RepaintObserver {
        CanvasWidget* owner = nullptr;
        RecordedCommands* stream = nullptr;
    };
 
public:
    enum class ContentMode { recorded_commands, native_painter };
    struct NativeGpuTextureFrame {
        void* texture_handle = nullptr;
        uint32_t width = 0;
        uint32_t height = 0;
        std::string format = "bgra8unorm";
        bool available = false;
    };
    using NativeGpuTextureProvider = std::function<NativeGpuTextureFrame()>;
 
    CanvasWidget()
        : repaint_observer_(std::make_shared<RepaintObserver>()) {
        repaint_observer_->owner = this;
        observe_recorded_commands();
    }
    ~CanvasWidget() override {
        repaint_observer_->owner = nullptr;
        repaint_observer_->stream = nullptr;
    }
 
    void set_native_painter(
        std::shared_ptr<NativeCanvasPainter> painter,
        NativeCanvasBackendRequirement requirement =
            NativeCanvasBackendRequirement::any) {
        native_painter_ = std::move(painter);
        native_backend_requirement_ = requirement;
        content_mode_ = native_painter_ ? ContentMode::native_painter
                                        : ContentMode::recorded_commands;
        request_repaint();
    }
    void reset_native_painter() {
        native_painter_.reset();
        native_backend_requirement_ = NativeCanvasBackendRequirement::any;
        content_mode_ = ContentMode::recorded_commands;
        request_repaint();
    }
    ContentMode content_mode() const noexcept { return content_mode_; }
    bool last_native_paint_succeeded() const noexcept {
        return last_native_paint_succeeded_;
    }
    canvas::RendererBackend last_native_paint_backend() const noexcept {
        return last_native_paint_backend_;
    }
 
    void clear_commands() {
        recorded_commands_->commands.clear();
        recorded_commands_->needs_backdrop_isolation = false;
        recorded_commands_->has_group_replays = false;
        // A recording still open at a frame clear was abandoned (its script
        // was interrupted before end_group); keep it from swallowing the
        // new frame.
        abort_group_recording();
        notify_recorded_command_consumers();
    }

    void add_command(CanvasDrawCmd cmd) {
        auto& stream = *recorded_commands_;
        cmd.x       = sanitize_finite(cmd.x);
        cmd.y       = sanitize_finite(cmd.y);
        cmd.w       = sanitize_finite(cmd.w);
        cmd.h       = sanitize_finite(cmd.h);
        cmd.x2      = sanitize_finite(cmd.x2);
        cmd.y2      = sanitize_finite(cmd.y2);
        cmd.x3      = sanitize_finite(cmd.x3);
        cmd.y3      = sanitize_finite(cmd.y3);
        cmd.extra   = sanitize_finite(cmd.extra);
        for (auto& p : cmd.gradient_positions) p = sanitize_finite(p);
        if (stream.recording_group) {
            if (reads_backdrop(cmd)) stream.recording.reads_backdrop = true;
            stream.recording.commands.push_back(std::move(cmd));
            return;
        }
        if (reads_backdrop(cmd)) stream.needs_backdrop_isolation = true;
        stream.commands.push_back(std::move(cmd));
    }
 
    // ── Cached groups ──────────────────────────────────────────────────
    //
    // A cached group is a keyed command list recorded once and replayed by
    // reference, so static content (grids, scales, labels) costs one bridge
    // call per frame instead of one per draw. Groups live beside the frame's
    // command stream, not in it: clear_commands() does not drop them, and a
    // canvas sharing this stream (share_recorded_commands_from) shares them.
    //
    // A replay runs the stored commands in place, inside an implicit
    // save/restore and under whatever transform the stream holds at that
    // point, so its pixels and blend order are exactly those of drawing the
    // same commands directly. State set inside a group never leaks out, and
    // a restore() inside a group cannot pop state saved outside it.

    bool begin_group(std::string key) {
        auto& stream = *recorded_commands_;
        if (stream.recording_group) return false;
        stream.recording_group = true;
        stream.recording_key = std::move(key);
        stream.recording = CachedGroup{};
        return true;
    }

    bool end_group() {
        auto& stream = *recorded_commands_;
        if (!stream.recording_group) return false;
        stream.recording_group = false;
        auto key = std::move(stream.recording_key);
        stream.groups[key] = std::move(stream.recording);
        stream.recording = CachedGroup{};
        return replay_group(key);
    }

    bool replay_group(const std::string& key) {
        auto& stream = *recorded_commands_;
        if (stream.recording_group) return false;
        const auto it = stream.groups.find(key);
        if (it == stream.groups.end()) return false;
        if (it->second.reads_backdrop) stream.needs_backdrop_isolation = true;
        stream.has_group_replays = true;
        CanvasDrawCmd cmd;
        cmd.type = CanvasDrawCmd::Type::replay_group;
        cmd.text = key;
        stream.commands.push_back(std::move(cmd));
        return true;
    }

    void invalidate_group(const std::string& key) {
        recorded_commands_->groups.erase(key);
    }
    void invalidate_all_groups() {
        recorded_commands_->groups.clear();
        abort_group_recording();
    }
    size_t group_count() const { return recorded_commands_->groups.size(); }
    const std::vector<CanvasDrawCmd>* group_commands(const std::string& key) const {
        const auto it = recorded_commands_->groups.find(key);
        return it == recorded_commands_->groups.end() ? nullptr : &it->second.commands;
    }
    size_t command_count() const { return recorded_commands_->commands.size(); }

    bool needs_backdrop_isolation() const {
        return recorded_commands_->needs_backdrop_isolation;
    }

    static bool reads_backdrop(const CanvasDrawCmd& cmd) {
        using T = CanvasDrawCmd::Type;
        if (cmd.type == T::clear_rect || cmd.type == T::put_image_data) return true;
        if (cmd.type != T::set_blend_mode) return false;
        const auto mode = static_cast<canvas::Canvas::BlendMode>(cmd.int_val);
        return mode != canvas::Canvas::BlendMode::normal &&
               mode != canvas::Canvas::BlendMode::source_over;
    }

    std::vector<const CanvasDrawCmd*> replay_sequence() const;
    const std::vector<CanvasDrawCmd>& commands() const {
        return recorded_commands_->commands;
    }

    void share_recorded_commands_from(CanvasWidget& source) {
        if (recorded_commands_ == source.recorded_commands_) return;
        recorded_commands_ = source.recorded_commands_;
        observe_recorded_commands();
        request_repaint();
    }
    bool last_native_gpu_texture_draw_succeeded() const { return last_native_gpu_texture_draw_succeeded_; }
    void set_native_gpu_texture_provider(NativeGpuTextureProvider provider) {
        native_gpu_texture_provider_ = std::move(provider);
    }

    void set_shader_effect(std::string name, float intensity = 1.0f) {
        shader_effect_name_ = std::move(name);
        shader_effect_intensity_ = std::clamp(intensity, 0.0f, 1.0f);
    }

    const std::string& shader_effect() const { return shader_effect_name_; }
    float shader_effect_intensity() const { return shader_effect_intensity_; }
 
    void paint(canvas::Canvas& canvas) override;
 
private:
    static float sanitize_finite(float v) noexcept {
        return std::isfinite(v) ? v : 0.0f;
    }
 
    struct CachedGroup {
        std::vector<CanvasDrawCmd> commands;
        bool reads_backdrop = false;
    };
    struct RecordedCommands {
        std::vector<CanvasDrawCmd> commands;
        bool needs_backdrop_isolation = false;
        bool has_group_replays = false;
        std::unordered_map<std::string, CachedGroup> groups;
        bool recording_group = false;
        std::string recording_key;
        CachedGroup recording;
        std::vector<std::weak_ptr<RepaintObserver>> observers;
    };
    void abort_group_recording() {
        auto& stream = *recorded_commands_;
        stream.recording_group = false;
        stream.recording_key.clear();
        stream.recording = CachedGroup{};
    }
    static void append_replay_sequence(const RecordedCommands& stream,
                                       std::vector<const CanvasDrawCmd*>& out);
    void observe_recorded_commands() {
        repaint_observer_->stream = recorded_commands_.get();
        recorded_commands_->observers.emplace_back(repaint_observer_);
    }
    void notify_recorded_command_consumers() {
        auto& observers = recorded_commands_->observers;
        observers.erase(std::remove_if(observers.begin(), observers.end(),
            [this](const std::weak_ptr<RepaintObserver>& weak) {
                auto observer = weak.lock();
                if (!observer) return true;
                // Bounded to the canvas's own box: paint() clips every
                // replay to the widget bounds (or a layer of the same size),
                // so a redrawn canvas cannot touch a pixel outside them. A
                // whole-surface request here made every animating canvas --
                // an analyzer, a modulated plot -- repaint the editor's
                // static chrome each frame on a partial-repaint host.
                if (observer->owner && observer->stream == recorded_commands_.get())
                    observer->owner->request_repaint_self(1.0f);
                return false;
            }), observers.end());
    }
    std::shared_ptr<RecordedCommands> recorded_commands_ =
        std::make_shared<RecordedCommands>();
    std::shared_ptr<RepaintObserver> repaint_observer_;
    std::shared_ptr<NativeCanvasPainter> native_painter_;
    NativeCanvasBackendRequirement native_backend_requirement_ =
        NativeCanvasBackendRequirement::any;
    ContentMode content_mode_ = ContentMode::recorded_commands;
    std::uint64_t native_frame_id_ = 0;
    bool last_native_paint_succeeded_ = false;
    canvas::RendererBackend last_native_paint_backend_ =
        canvas::RendererBackend::unknown;
    NativeGpuTextureProvider native_gpu_texture_provider_;
    bool last_native_gpu_texture_draw_succeeded_ = false;
    // Curated named GPU post-effect state (see set_shader_effect). Sticky
    // across command-list rebuilds; "none"/"" means no effect.
    std::string shader_effect_name_ = "none";
    float shader_effect_intensity_ = 1.0f;
};
 
} // namespace pulp::view