Martino Ferrari
38ef459897
Breaking: Series::gather emits x relative to x0() and takes a GatherMode; consumers reconstruct absolute x in f64 before mapping (series.hpp documents the contract). Bugs, each pinned by a fail-before regression test: - render: f32 staging quantised epoch-time x into 128 px columns; every data-space draw now stages to_space(x) - to_space(origin) with the origin folded into the offset uniform in f64 (epoch/zero-origin twins rasterise identically) - ticks: major test was ULP-fragile and blanked epoch axes; majors are an integer-index test and are never truncated by the minor cap - gather: LOD envelope emitted buckets straddling [begin,end); ceil/floor bucket edges + raw lead/trail spans - live follow: log x axes held a linear span and zoomed every frame; span and offset now live in axis space (plot + both figure link-group paths) - input: a zero-notch wheel disarmed auto_scale on every axis; dy==0 pans x, factor == 1 / inf refused in wheel and drag zoom - render: the single text flush painted legend names over the crosshair readout panel; two batches, under flushed before the panel - data: NaN dropped from min/max unless it seeded the fold; non-finite samples are now excluded from every aggregate and from cached bounds Robustness: viewport normalisation (no clamp UB), non-finite range refusal, pyramid level cap at 57 (no shift/div UB through public gather), rounded ring capacity documented + pre-sized, GL blend func and UNPACK_ALIGNMENT save/restore, Renderer::release_gl() teardown, u64 buffer epochs, annotation captions clamped, button-aware GLFW row capture, cached figure row rects (no per-event layout), ruler-pair measurement refused, span-nonfinite guards in axis_ends. Features: XY series (sorted x, binary-search neighbours/snap, LOD over sample index); StreamSeries::freeze(); ArraySeries::push(); per-trace dash and markers (scatter at width 0) with auto or literal stride; GatherMode Envelope/Nearest/Mean via bucket_sum/sumsq; Style::line_aa_px; per-glyph text colour (readout values in trace colour); wheel-dx x pan; arrow-key pan; Escape cancels a drag and restores captured ranges; modifier-masked box zoom (Shift both, Ctrl x, Alt y); double-click reset via PointerEvent::time_s; ImGui key repeat unified; pinch gestures on Qt and GTK; pixelDelta wheel path and DevicePixelRatioChange handling; GNUInstallDirs, SOVERSION, SameMinorVersion, generated plot/version.hpp, relocatable plot.pc, licence install, FILES_MATCHING, GitHub Actions CI (debug/coverage/asan). Suite 283 -> 350 cases, 0 failed; coverage 93.9% (3730/3971) over 24 files, floor 80/90 held; ASAN preset suite green; all four demos run headless (the GTK scripted-resize check needs a window manager and fails identically on the parent commit); readme_main.cpp committed and compiles with the README command; pkg-config and find_package consumption verified from a relocated install prefix.
112 lines
4.0 KiB
C++
112 lines
4.0 KiB
C++
// SPDX-License-Identifier: MIT
|
|
// SPDX-FileCopyrightText: 2026 Martino Ferrari
|
|
|
|
#include <plot/render/vertex_array.hpp>
|
|
|
|
#include <plot/gl/api.hpp>
|
|
|
|
#include <cstddef>
|
|
|
|
namespace plot::render {
|
|
namespace {
|
|
|
|
/// Instance data advances one step per instance, never per vertex: both
|
|
/// pipelines draw one quad per instance with corners synthesised from
|
|
/// `gl_VertexID`, so every attribute has a divisor of 1 (core since GL 3.3).
|
|
constexpr gl::GLuint kPerInstance = 1;
|
|
|
|
} // namespace
|
|
|
|
bool LineVertexArray::create(Status* st, UploadMode mode) noexcept {
|
|
if (!vao_.create(st)) {
|
|
return false;
|
|
}
|
|
if (!buffer_.create(st, mode)) {
|
|
vao_.reset(); // do not leave a vertex array behind on the failure path
|
|
return false;
|
|
}
|
|
// Attribute pointers capture the bound GL_ARRAY_BUFFER, so bind both first.
|
|
vao_.bind();
|
|
buffer_.bind();
|
|
// Offsets come from the struct, not from counting floats: the layout is the
|
|
// one shaders.hpp declares, and it stays in step with LineInstance.
|
|
vao_.attrib(0u, 2, sizeof(LineInstance), offsetof(LineInstance, x0));
|
|
vao_.attrib(1u, 2, sizeof(LineInstance), offsetof(LineInstance, x1));
|
|
gl::glVertexAttribDivisor(0u, kPerInstance);
|
|
gl::glVertexAttribDivisor(1u, kPerInstance);
|
|
gl::glBindVertexArray(0); // leave the binding as we found it
|
|
epoch_ = buffer_.epoch();
|
|
return true;
|
|
}
|
|
|
|
void LineVertexArray::upload(const f32* interleaved, u32 segments) noexcept {
|
|
// An array that was never created reports nothing to draw, so a caller that
|
|
// ignored create()'s status rasterises nothing instead of stale memory.
|
|
if (interleaved == nullptr || vao_.id() == 0) {
|
|
instances_ = 0;
|
|
return;
|
|
}
|
|
buffer_.upload(interleaved, segments);
|
|
// Only the mapped transfer moves the instances between slots, and the
|
|
// attribute offsets have to follow them. The generation changes for a new slot
|
|
// or a re-created buffer, never otherwise, so the baseline path re-points at
|
|
// most once.
|
|
if (buffer_.epoch() != epoch_) {
|
|
const usize base = buffer_.slot_offset();
|
|
vao_.bind();
|
|
buffer_.bind();
|
|
vao_.attrib(0u, 2, sizeof(LineInstance), base + offsetof(LineInstance, x0));
|
|
vao_.attrib(1u, 2, sizeof(LineInstance), base + offsetof(LineInstance, x1));
|
|
epoch_ = buffer_.epoch();
|
|
}
|
|
instances_ = segments;
|
|
}
|
|
|
|
bool TextVertexArray::create(Status* st, UploadMode mode) noexcept {
|
|
if (!vao_.create(st)) {
|
|
return false;
|
|
}
|
|
if (!buffer_.create(st, mode)) {
|
|
vao_.reset();
|
|
return false;
|
|
}
|
|
vao_.bind();
|
|
buffer_.bind();
|
|
// Four attributes now: the cell's corner, its atlas rect, the basis that
|
|
// rotates it and the run's tint (see TextInstance). All of them advance once
|
|
// per instance, like the line pipeline's, because the corners come from
|
|
// gl_VertexID.
|
|
vao_.attrib(0u, 2, sizeof(TextInstance), offsetof(TextInstance, x));
|
|
vao_.attrib(1u, 2, sizeof(TextInstance), offsetof(TextInstance, u));
|
|
vao_.attrib(2u, 2, sizeof(TextInstance), offsetof(TextInstance, ax));
|
|
vao_.attrib(3u, 4, sizeof(TextInstance), offsetof(TextInstance, r));
|
|
gl::glVertexAttribDivisor(0u, kPerInstance);
|
|
gl::glVertexAttribDivisor(1u, kPerInstance);
|
|
gl::glVertexAttribDivisor(2u, kPerInstance);
|
|
gl::glVertexAttribDivisor(3u, kPerInstance);
|
|
gl::glBindVertexArray(0);
|
|
epoch_ = buffer_.epoch();
|
|
return true;
|
|
}
|
|
|
|
void TextVertexArray::upload(const f32* interleaved, u32 glyphs) noexcept {
|
|
if (interleaved == nullptr || vao_.id() == 0) {
|
|
instances_ = 0;
|
|
return;
|
|
}
|
|
buffer_.upload(interleaved, glyphs);
|
|
if (buffer_.epoch() != epoch_) {
|
|
const usize base = buffer_.slot_offset();
|
|
vao_.bind();
|
|
buffer_.bind();
|
|
vao_.attrib(0u, 2, sizeof(TextInstance), base + offsetof(TextInstance, x));
|
|
vao_.attrib(1u, 2, sizeof(TextInstance), base + offsetof(TextInstance, u));
|
|
vao_.attrib(2u, 2, sizeof(TextInstance), base + offsetof(TextInstance, ax));
|
|
vao_.attrib(3u, 4, sizeof(TextInstance), base + offsetof(TextInstance, r));
|
|
epoch_ = buffer_.epoch();
|
|
}
|
|
instances_ = glyphs;
|
|
}
|
|
|
|
} // namespace plot::render
|