Martino Ferrari
3c0e7763ab
The persistent-mapped instance ring had three slots and recorded a fence per upload, so a frame recycled a slot whose fence was recorded a few draws earlier *in that same frame*: from the fourth of the demos' nine uploads on, each one waited on the frame's own work. It is free on a driver that retires draws promptly (the GLFW host, 1.07 ms/frame) and ~4 ms of the Qt widget's 7.11 ms under llvmpipe, and it grows with the trace and cursor counts this library exists for. * The ring grows to cover a frame's upload count, the frame's write cursor is the ring index (so a frame writes 0, 1, 2, ... and never a slot twice), one fence is recorded after the frame's last draw, and the only wait is at the start of the next frame. A wait that times out, or a slot written with no fence ever recorded behind it, drops the store to the orphan path -- the treatment a refused fence already had -- so nothing is ever written into storage the GPU may still be reading. * New test-only counters (PLOT_RING_STATS, the PLOT_PYRAMID_COUNT_* pattern: free functions, no member, so no consumer's layout changes) pin a frame's upload and wait counts. The new tests assert the frame's slot offsets are distinct, that the ring grew past its floor to cover the frame, and that a frame waits at most once per store -- read from the counters and from glClientWaitSync itself. * qt6: print the unresolved entry-point names before the load-failure branch, which used to return first and leave the one failure this widget can have reporting nothing but a generic message. * qt6: the cached pointer anchor is now in logical pixels and a move's delta is the logical difference scaled by the DPR in effect, so a scale change between two move events (the window dragged onto another monitor mid-drag) is no longer a cross-scale jump applied as a pan. The anchor moved into a toolkit-free unit (adapters/qt6/qt_pointer.hpp) with its own test. GLFW demo headless: 1.07 -> 0.73 ms/frame. Qt widget under xvfb/llvmpipe: 7.1 -> 3.8 ms at dpr 1.0, 6.7 -> 3.6 ms at 1.25, with both upload paths still rendering and the demo's scripted pan/box-zoom checks passing at both scales.
85 lines
3.6 KiB
C++
85 lines
3.6 KiB
C++
#pragma once
|
|
#include <plot/core/status.hpp>
|
|
#include <plot/core/types.hpp>
|
|
#include <plot/gl/handle.hpp>
|
|
#include <plot/render/buffer.hpp>
|
|
|
|
namespace plot::render {
|
|
|
|
/// Vertex array plus instance buffer of the line pipeline.
|
|
///
|
|
/// The attribute layout is fixed by the line shader (see shaders.hpp): `a_p0` at
|
|
/// location 0 and `a_p1` at location 1, two floats each, advancing once per
|
|
/// instance. A caller never writes a location, stride or offset; it stages a
|
|
/// `LineBatch` and uploads its `data()`.
|
|
///
|
|
/// The instance buffer may sit behind either transfer strategy (see
|
|
/// `UploadMode`). Only the mapped one moves the instances between slots, so
|
|
/// `upload()` re-points the attributes when `InstanceStore::epoch()` changes and
|
|
/// otherwise leaves them alone; the caller never has to know which path is live.
|
|
class LineVertexArray {
|
|
public:
|
|
/// Creates the vertex array, the instance buffer and the attribute layout.
|
|
/// `mode` selects the instance buffer's transfer strategy and defaults to the
|
|
/// GL 3.3 baseline; a caller asking for `UploadMode::PersistentMapped` must
|
|
/// have checked the context can do it (see `Renderer::init()`).
|
|
bool create(Status* st = nullptr, UploadMode mode = UploadMode::Orphan) noexcept;
|
|
|
|
/// Uploads `segments` instances from interleaved `x0,y0,x1,y1` floats and
|
|
/// records how many the next draw should rasterise.
|
|
void upload(const f32* interleaved, u32 segments) noexcept;
|
|
|
|
void bind() const noexcept { vao_.bind(); }
|
|
/// Waits, once, for the previous frame's draws to retire the ring before any
|
|
/// slot of this frame is written (see `InstanceStore::begin_frame`). False when
|
|
/// the store had to drop to the baseline path; the caller reports it.
|
|
bool begin_frame() noexcept { return buffer_.begin_frame(); }
|
|
/// Records the frame's single fence, behind every draw that read the ring (see
|
|
/// `InstanceStore::mark_drawn`); called once per frame, after its last draw.
|
|
/// False only when the driver refused the fence: the buffer has then fallen
|
|
/// back to the baseline path, and `persistent()` says so from the next call on.
|
|
bool mark_drawn() noexcept { return buffer_.mark_drawn(); }
|
|
/// True while this array's instance buffer is the mapped ring (see
|
|
/// `UploadMode`); a failure that falls back clears it.
|
|
bool persistent() const noexcept { return buffer_.persistent(); }
|
|
|
|
bool valid() const noexcept { return vao_.id() != 0; }
|
|
u32 instance_count() const noexcept { return instances_; }
|
|
|
|
private:
|
|
LineBuffer buffer_;
|
|
gl::VertexArray vao_;
|
|
u32 instances_ = 0;
|
|
/// Instance-buffer generation the attribute pointers currently point into.
|
|
u32 epoch_ = 0;
|
|
};
|
|
|
|
/// Vertex array plus instance buffer of the text pipeline: `a_pos` at location 0
|
|
/// and the glyph's atlas texel origin `a_uv` at location 1, two floats each,
|
|
/// advancing once per instance.
|
|
class TextVertexArray {
|
|
public:
|
|
bool create(Status* st = nullptr, UploadMode mode = UploadMode::Orphan) noexcept;
|
|
|
|
/// Uploads `glyphs` instances from interleaved `x,y,u,v` floats.
|
|
void upload(const f32* interleaved, u32 glyphs) noexcept;
|
|
|
|
void bind() const noexcept { vao_.bind(); }
|
|
/// The line pipeline's frame pair, for the text store (see
|
|
/// `LineVertexArray::begin_frame` / `mark_drawn`).
|
|
bool begin_frame() noexcept { return buffer_.begin_frame(); }
|
|
bool mark_drawn() noexcept { return buffer_.mark_drawn(); }
|
|
bool persistent() const noexcept { return buffer_.persistent(); }
|
|
|
|
bool valid() const noexcept { return vao_.id() != 0; }
|
|
u32 instance_count() const noexcept { return instances_; }
|
|
|
|
private:
|
|
TextBuffer buffer_;
|
|
gl::VertexArray vao_;
|
|
u32 instances_ = 0;
|
|
u32 epoch_ = 0;
|
|
};
|
|
|
|
} // namespace plot::render
|