render_pass.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <vector>
 
namespace pulp::render {

enum class RenderPassType {
    background,     
    content,        
    effects,        
    overlay,        
    post_effects    
};

struct PassStats {
    RenderPassType type;
    int draw_calls = 0;
    float time_ms = 0;        

    float cpu_time_ms() const { return time_ms; }
};

class RenderPassManager {
public:
    void begin_frame() {
        passes_.clear();
        current_pass_ = RenderPassType::background;
        frame_count_++;
        total_time_ms_ = 0;
        over_budget_ = false;
        // Invalidate last frame's whole-recording GPU sample; a fresh sample
        // (if any) is fed in via set_gpu_render_time_ms() for this frame. The
        // value itself is left as-is so a stale read between begin_frame() and
        // the next set is reported as invalid rather than as a bogus 0.
        gpu_render_time_valid_ = false;
    }

    void begin_pass(RenderPassType type) {
        current_pass_ = type;
        passes_.push_back({type, 0, 0});
    }

    void end_pass(float time_ms = 0, int draw_calls = 0) {
        if (!passes_.empty()) {
            passes_.back().time_ms = time_ms;
            passes_.back().draw_calls = draw_calls;
            total_time_ms_ += time_ms;
        }
    }

    void end_frame() {
        // Check if we exceeded budget
        over_budget_ = (budget_ms_ > 0 && total_time_ms_ > budget_ms_);
    }

    void set_gpu_render_time_ms(float ms, bool valid) {
        if (valid && ms >= 0.0f) {
            gpu_render_time_ms_ = ms;
            gpu_render_time_valid_ = true;
        } else {
            gpu_render_time_valid_ = false;
        }
    }

    float gpu_render_time_ms() const { return gpu_render_time_ms_; }

    bool gpu_render_timing_available() const { return gpu_render_time_valid_; }

    void set_budget(float ms) { budget_ms_ = ms; }
    float budget() const { return budget_ms_; }

    bool over_budget() const { return over_budget_; }

    float total_time_ms() const { return total_time_ms_; }

    const std::vector<PassStats>& passes() const { return passes_; }

    uint64_t frame_count() const { return frame_count_; }

    RenderPassType current_pass() const { return current_pass_; }
 
private:
    std::vector<PassStats> passes_;
    RenderPassType current_pass_ = RenderPassType::background;
    float budget_ms_ = 16.67f;  // 60fps default
    float total_time_ms_ = 0;
    bool over_budget_ = false;
    uint64_t frame_count_ = 0;
    // Frame-level (whole-recording) GPU render time. This is the ONLY GPU-clock
    // granularity Pulp exposes — per-pass GPU timing is structurally unavailable
    // under Skia Graphite (see PassStats + set_gpu_render_time_ms()).
    float gpu_render_time_ms_ = 0.0f;
    bool gpu_render_time_valid_ = false;
};
 
} // namespace pulp::render