gpu_surface.hpp

Go to the documentation of this file.

#pragma once
 
#if defined(PULP_GPU_RUNTIME)
// This build's device layer is gpu-runtime's (tools/cmake/PulpGpuRuntime.cmake):
// these are its types and functions under their Pulp names, so a Pulp object
// and a gpu-runtime object are one and the same.
#include <gpu_runtime/gpu_surface.hpp>
 
namespace pulp::render {
using gpu_runtime::GpuSurface;
using gpu_runtime::SwapchainResizeState;
} // namespace pulp::render
#else // !PULP_GPU_RUNTIME
 
#include <cstdint>
#include <memory>
#include <string>
 
namespace pulp::render {

class SwapchainResizeState {
  public:
    void request(uint32_t width, uint32_t height) {
        requested_width_ = width;
        requested_height_ = height;
    }

    void mark_configured() {
        configured_width_ = requested_width_;
        configured_height_ = requested_height_;
        configured_ = true;
    }

    void invalidate() {
        configured_ = false;
    }

    bool presentable() const {
        return requested_width_ != 0 && requested_height_ != 0;
    }

    bool needs_configure() const {
        return presentable() && (!configured_ || requested_width_ != configured_width_ ||
                                 requested_height_ != configured_height_);
    }

    void note_frame(bool configured) {
        if (configured)
            stable_frames_ = 0;
        else if (stable_frames_ < kSettleFrames)
            ++stable_frames_;
    }

    bool settled() const {
        return presentable() && !needs_configure() && stable_frames_ >= kSettleFrames;
    }
 
    static constexpr uint32_t kSettleFrames = 2;

    uint32_t width() const {
        return requested_width_;
    }
    uint32_t height() const {
        return requested_height_;
    }
 
  private:
    uint32_t requested_width_ = 0;
    uint32_t requested_height_ = 0;
    uint32_t configured_width_ = 0;
    uint32_t configured_height_ = 0;
    bool configured_ = false;
    uint32_t stable_frames_ = 0;
};

class GpuSurface {
public:
    enum class AdapterType {
        unknown,
        integrated_gpu,
        discrete_gpu,
        cpu,
    };
 
    enum class AdapterBackendPreference {
        default_backend,
        null_backend,
        vulkan,
        d3d12,
    };
 
    struct AdapterInfo {
        bool available = false;
        bool native_bridge = false;
        AdapterType adapter_type = AdapterType::unknown;
        bool null_backend = false;
        std::string backend = "unavailable";
        std::string backend_type = "Unknown";
        std::string name = "Mock Dawn Adapter";
        std::string vendor = "Pulp";
        std::string architecture = "unavailable";
        std::string description = "Mock Dawn Adapter";
        std::string preferred_canvas_format = "bgra8unorm";
    };
 
    struct Config {
        uint32_t width = 800;
        uint32_t height = 600;
        bool vsync = true;

        bool enable_gpu_timing = false;
 
        bool force_fallback_adapter = false;
        AdapterBackendPreference backend_preference =
            AdapterBackendPreference::default_backend;

        void* native_surface_handle = nullptr;
    };

    struct X11NativeHandle {
        void*         display = nullptr;  // Display*
        unsigned long window  = 0;        // Window
    };
 
    virtual ~GpuSurface() = default;
 
    virtual bool initialize(const Config& config) = 0;

    virtual void resize(uint32_t width, uint32_t height) = 0;

    virtual bool begin_frame() = 0;

    virtual void end_frame() = 0;
 
    virtual bool is_initialized() const = 0;
    virtual bool has_surface() const = 0;
    virtual uint32_t width() const = 0;
    virtual uint32_t height() const = 0;

    virtual void* dawn_device_handle() const = 0;
    virtual void* dawn_queue_handle() const = 0;
    virtual void* dawn_instance_handle() const = 0;

    virtual void* current_texture_handle() const = 0;

    virtual AdapterInfo adapter_info() const = 0;
 
    static std::unique_ptr<GpuSurface> create_dawn();

    struct StartupTimings {
        double instance_ms = -1.0;
        double adapter_ms = -1.0;
        double device_ms = -1.0;
        double surface_ms = -1.0;
    };

    virtual StartupTimings startup_timings() const { return {}; }

    struct SwapchainStats {
        uint64_t configure_count = 0;
        double configure_ms = 0.0;
        bool settled = false;
    };

    virtual SwapchainStats swapchain_stats() const {
        return {};
    }
};
 
} // namespace pulp::render
 
#endif // PULP_GPU_RUNTIME