plugin_frame_renderer.hpp

Go to the documentation of this file.

#pragma once
 
// plugin_frame_renderer.hpp — the damage-aware frame pipeline shared by the
// Windows and Linux plug-in editor hosts.
//
// Both hosts had their own copy of: the background fill and design-viewport
// paint body, the damage → clip decision (hazard model, letterbox mapping,
// pixel snapping), and the acquire → paint → readback → submit → present
// sequence. The copies had already drifted — only one of them checked the
// readback result — and every WAH-2 failure-semantics fix would otherwise have
// had to be made twice, correctly, forever.
//
// The split here is deliberate:
//
//   * `FrameGeometry`, `compute_frame_clip()` and `paint_plugin_scene()` are
//     pure and Skia-free, so they compile and are TESTED on macOS — which is
//     Pulp's required CI gate. Logic reachable only under `_WIN32` is logic no
//     gate ever runs (the same reasoning as win_pointer_input.hpp).
//   * `PluginFrameRenderer` owns the GPU drive and the failure policy, and only
//     exists in Skia builds.
//
// Native window ownership (HWND/X11), event dispatch, and attach/detach stay in
// the platform hosts. This module never touches a native handle.
 
#include <pulp/view/geometry.hpp>
#include <pulp/view/plugin_view_host.hpp>
#include <pulp/view/pending_damage.hpp>
 
#include <cstdint>
 
namespace pulp::canvas {
class Canvas;
}
 
namespace pulp::view {
 
class View;

struct FrameGeometry {
    float width = 0.0f;
    float height = 0.0f;
    float scale = 1.0f;
    float design_width = 0.0f;   
    float design_height = 0.0f;
    bool design_top_align = false;
    std::uint32_t background_rgb = kEditorHostClearRgb;

    std::uint32_t physical_width = 0;
    std::uint32_t physical_height = 0;
 
    bool has_design_viewport() const {
        return design_width > 0.0f && design_height > 0.0f;
    }

    std::uint32_t pixel_width() const {
        return physical_width ? physical_width : to_pixels(width);
    }
    std::uint32_t pixel_height() const {
        return physical_height ? physical_height : to_pixels(height);
    }
 
private:
    std::uint32_t to_pixels(float logical) const {
        const float p = logical * scale;
        return static_cast<std::uint32_t>(p < 1.0f ? 1.0f : p);
    }
};

bool compute_frame_clip(View& root, const PendingDamage::Snapshot& damage,
                        const FrameGeometry& geometry, Rect& out_clip);

void paint_plugin_scene(canvas::Canvas& canvas, View& root,
                        const FrameGeometry& geometry, const Rect* clip);
 
}  // namespace pulp::view
 
#ifdef PULP_HAS_SKIA
 
#include <pulp/render/gpu_surface.hpp>
#include <pulp/render/skia_surface.hpp>
 
#include <cstdint>
#include <functional>
#include <memory>
#include <vector>
 
#include <pulp/platform/gpu_fwd.hpp>
 
namespace pulp::view {

class PluginFrameRenderer {
public:
    static constexpr int kMaxConsecutiveRecreates = 3;
 
    struct Frame {
        render::FrameOutcome outcome = render::FrameOutcome::failed;
        bool readback_ok = true;
        bool should_recreate_surface = false;
        bool gpu_path_exhausted = false;
 
        bool reached_output() const {
            return render::frame_reached_output(outcome);
        }
    };
 
    struct Request {
        View* root = nullptr;
        FrameGeometry geometry{};
        bool partial_repaint = false;
        std::function<void()> idle;
        std::vector<std::uint8_t>* capture = nullptr;
        std::uint32_t* capture_width = nullptr;
        std::uint32_t* capture_height = nullptr;
    };

    Frame render(render::GpuSurface& gpu, render::SkiaSurface& skia,
                 PendingDamage& damage, const Request& request);

    void note_surfaces_created() { consecutive_recreates_ = 0; }
 
    int consecutive_recreates() const { return consecutive_recreates_; }
 
private:
    Frame& finish(Frame& frame, render::FrameOutcome outcome);
 
    int consecutive_recreates_ = 0;
};

struct EditorSurfaces {
    std::unique_ptr<render::GpuSurface> gpu;
    std::unique_ptr<render::SkiaSurface> skia;
    bool partial_repaint = false;
 
    bool ok() const { return gpu != nullptr && skia != nullptr; }
};

render::GpuSurface::Config editor_surface_config(
    void* native_handle, const FrameGeometry& geometry,
    PluginViewHost::PresentPolicy policy, bool enable_gpu_timing);

EditorSurfaces create_editor_surfaces(void* native_handle,
                                      const FrameGeometry& geometry,
                                      PluginViewHost::PresentPolicy policy,
                                      bool enable_gpu_timing,
                                      bool want_partial_repaint,
                                      const char* log_tag);

class RasterSceneCache {
  public:
    RasterSceneCache();
    ~RasterSceneCache();
 
    RasterSceneCache(const RasterSceneCache&) = delete;
    RasterSceneCache& operator=(const RasterSceneCache&) = delete;
 
  private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
    friend std::vector<std::uint8_t> raster_plugin_scene_rgba(View&, const FrameGeometry&,
                                                              std::uint32_t*, std::uint32_t*,
                                                              canvas::TextRasterPolicy,
                                                              RasterSceneCache*);
};

std::vector<std::uint8_t>
raster_plugin_scene_rgba(View& root, const FrameGeometry& geometry, std::uint32_t* out_w,
                         std::uint32_t* out_h,
                         canvas::TextRasterPolicy text_raster = canvas::TextRasterPolicy::legacy,
                         RasterSceneCache* retained_cache = nullptr);

std::vector<std::uint8_t> encode_rgba_png(const std::vector<std::uint8_t>& rgba,
                                          std::uint32_t w, std::uint32_t h);
 
}  // namespace pulp::view
 
#endif  // PULP_HAS_SKIA