skia_surface.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/render/gpu_surface.hpp>
#include <pulp/canvas/canvas.hpp>
#include <pulp/canvas/text_raster_policy.hpp>
#include <algorithm>
#include <array>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <functional>
#include <optional>
#include <vector>
 
namespace skgpu::graphite {
class Context;
}
 
namespace pulp::render {

enum class FrameOutcome {
    presented,
    offscreen,
    recreate,
    failed,
};

constexpr bool frame_reached_output(FrameOutcome outcome) {
    return outcome == FrameOutcome::presented ||
           outcome == FrameOutcome::offscreen;
}

struct GpuCacheBytes {
    std::size_t budgeted = 0;
    std::size_t purgeable = 0;
};

class GpuIdleTrimSchedule {
  public:
    using Clock = std::chrono::steady_clock;
    static constexpr std::chrono::milliseconds kInterval{1000};
    static constexpr std::chrono::milliseconds kUnusedAge{2000};
    static constexpr std::size_t kUnusedFrames = 30;
 
    explicit GpuIdleTrimSchedule(Clock::time_point start) : last_(start) {}

    void note_frame(Clock::time_point start) {
        frame_starts_[next_] = start;
        next_ = (next_ + 1) % kUnusedFrames;
        if (frames_ < kUnusedFrames)
            ++frames_;
    }

    std::optional<std::chrono::milliseconds> unused_age(Clock::time_point now) const {
        if (frames_ < kUnusedFrames)
            return std::nullopt;
        // With the ring full, the next slot to overwrite is the oldest start.
        const auto span = std::chrono::ceil<std::chrono::milliseconds>(now - frame_starts_[next_]);
        return std::max(kUnusedAge, span);
    }

    bool due(Clock::time_point now) {
        if (now - last_ < kInterval)
            return false;
        last_ = now;
        ++trims_;
        return true;
    }

    std::uint64_t trims() const {
        return trims_;
    }
 
  private:
    Clock::time_point last_;
    std::uint64_t trims_ = 0;
    std::array<Clock::time_point, kUnusedFrames> frame_starts_{};
    std::size_t next_ = 0;
    std::size_t frames_ = 0;
};

class SkiaSurface {
public:
    struct Config {
        uint32_t width = 800;
        uint32_t height = 600;
        float scale_factor = 1.0f;  // HiDPI
        canvas::TextRasterPolicy text_raster_policy = canvas::TextRasterPolicy::legacy;
    };

    static std::unique_ptr<SkiaSurface> create(GpuSurface& gpu, const Config& config);
 
#if defined(__EMSCRIPTEN__)
    struct WebGlConfig {
        const char* canvas_selector = "#pulp";
        uint32_t width = 0;
        uint32_t height = 0;
        float scale_factor = 1.0f;  // devicePixelRatio
        canvas::TextRasterPolicy text_raster_policy = canvas::TextRasterPolicy::legacy;
    };

    static std::unique_ptr<SkiaSurface> create_webgl(const WebGlConfig& config);
#endif
 
    virtual ~SkiaSurface() = default;

    virtual canvas::Canvas* begin_frame() = 0;

    virtual FrameOutcome end_frame() = 0;

    virtual FrameOutcome last_frame_outcome() const { return FrameOutcome::offscreen; }

    virtual bool has_presentable_target() const = 0;

    virtual void resize(uint32_t width, uint32_t height, float scale = 1.0f) = 0;

    virtual bool set_persistent_scene(bool /*enable*/) { return false; }

    virtual bool persistent_scene() const { return false; }

    virtual void set_text_raster_policy(canvas::TextRasterPolicy /*policy*/) {}

    virtual canvas::TextRasterPolicy text_raster_policy() const {
        return canvas::TextRasterPolicy::legacy;
    }

    virtual bool read_current_rgba(std::vector<uint8_t>& pixels,
                                   uint32_t& pixel_width,
                                   uint32_t& pixel_height) = 0;

    virtual bool is_available() const = 0;

    virtual skgpu::graphite::Context* graphite_context() const = 0;

    virtual double gpu_render_time_ms() const = 0;

    virtual bool gpu_render_timing_available() const = 0;

    virtual int gpu_frames_in_flight() const { return -1; }

    virtual bool wait_for_submitted_work() {
        return false;
    }

    class TrimLevel {
      public:
        static TrimLevel unused_for(std::chrono::milliseconds idle) {
            return TrimLevel(idle, false);
        }

        static TrimLevel everything() {
            return TrimLevel({}, true);
        }
 
        bool frees_everything() const {
            return everything_;
        }
        std::chrono::milliseconds idle() const {
            return idle_;
        }
 
      private:
        TrimLevel(std::chrono::milliseconds idle, bool everything)
            : idle_(idle), everything_(everything) {}
        std::chrono::milliseconds idle_;
        bool everything_;
    };

    virtual void trim_gpu_resources(TrimLevel /*level*/) {}

    virtual GpuCacheBytes gpu_cache_bytes() const {
        return {};
    }

    virtual std::uint64_t idle_trim_count() const {
        return 0;
    }

    virtual std::uint64_t render_target_allocations() const {
        return 0;
    }
 
#if !defined(__EMSCRIPTEN__)
    using InsertOutcomeHook = bool (*)(bool accepted);
    static void set_insert_outcome_hook_for_testing(InsertOutcomeHook hook);

    static void set_async_readback_for_testing(bool enabled);

    using TrimClockHook = GpuIdleTrimSchedule::Clock::time_point (*)();
    static void set_trim_clock_for_testing(TrimClockHook hook);
#endif
};
 
} // namespace pulp::render