Martino Ferrari
f79a97be9b
A grid was the axes rect in device pixels, so dragging a window wide made the image wider with it -- and the per-frame pass over it is O(cells): the fade multiplies every cell, a host's ink()/peak() read every cell, and a frame the fade moved converts and uploads every cell as one byte. At 2x device scale a 1520x850 window's axes rect is 2877 device pixels wide, so four rows of one trace are 4.5 M cells and 4.9 MB uploaded a frame; measured headless on llvmpipe with a 2 s window, 12.9 ms of tick and 12.8 ms of draw a frame, every frame under a time fade -- a cost that follows the window and has no ceiling. The grid is now the axes rect up to kDensityCellCap (2^18 cells, a mebibyte of counts), scaled down uniformly past it so cells stay square and the picture keeps the axes' aspect, and magnified back over the rect with a linear filter: a cell is a count, so a fragment between two of them is between their two ink levels, which a point sample cannot give once a cell is several pixels wide. The same four rows at the cap are 1.05 M cells, 3.9 ms of tick and 5.6 ms of draw and 1.0 MB uploaded, while a grid under the cap is untouched -- a 640x360 viewport's 573x313 axes is still 179 349 cells, one a device pixel. The image's footprint is the axes rect rounded up to whole device pixels on both sides of the pipe, so a grid under the cap keeps the exact one-texel-a-pixel mapping it has always had (sx/sy come out exactly 1) and only a capped grid reads its cell index through a scale. Moving the decay itself to the GPU was considered and left out: the CPU grid is what ink()/peak() read, what the deposit adds to and what the per-sweep dedupe keys on, so a GPU image would have to be reconciled with it per frame -- a larger change than this bound, and not one to half-do. Tests: a_density_grid_is_capped_whatever_the_window reads the bound off a 3840x2160 viewport (261 504 cells of a 3784x2138 axes, aspect kept), a_capped_density_is_magnified_over_the_axes_rect reads the screen side of it (569x460 cells covering all 832 of the rect's columns), and the density cases now assert their capped figures. 399 cases, 0 failed.
121 lines
5.6 KiB
C++
121 lines
5.6 KiB
C++
// SPDX-License-Identifier: MIT
|
|
// SPDX-FileCopyrightText: 2026 Martino Ferrari
|
|
|
|
#pragma once
|
|
#include <plot/core/color.hpp>
|
|
#include <plot/core/status.hpp>
|
|
#include <plot/gl/handle.hpp>
|
|
#include <plot/math/vec2.hpp>
|
|
|
|
namespace plot::render {
|
|
|
|
/// Linked line program and its uniform surface.
|
|
///
|
|
/// It owns the `plot::gl::Program` and knows the GLSL pair (shaders.hpp), so no
|
|
/// caller spells out a uniform name that could drift from the shader. Creating
|
|
/// it propagates what the GL layer reports: `ErrorCode::Unsupported` while
|
|
/// `plot::gl::available()` is false, `GLFailure` plus the driver's log when the
|
|
/// GLSL does not compile or link.
|
|
class LineProgram {
|
|
public:
|
|
bool create(Status* st = nullptr) noexcept;
|
|
bool valid() const noexcept { return program_.id() != 0; }
|
|
void bind() const noexcept { program_.use(); }
|
|
|
|
/// `u_scale`: data space to pixels.
|
|
void set_scale(Vec2 data_to_px) const noexcept;
|
|
/// `u_offset`: pixel offset added after `set_scale`.
|
|
void set_offset(Vec2 px) const noexcept;
|
|
/// `u_viewport`: render target size in pixels.
|
|
void set_viewport(Vec2 px) const noexcept;
|
|
/// `u_width`: stroke width in pixels.
|
|
void set_width(f32 px) const noexcept;
|
|
/// `u_dash`: the dash pattern in pixels -- `x` the ink length, `y` the gap, and a
|
|
/// non-positive `y` (the default a caller passes) means **solid**. It is a fragment-shader
|
|
/// discard on the interpolated `v_along`, so it costs no geometry, and it is the one uniform
|
|
/// that distinguishes the crosshair's stroke from every other line in the library.
|
|
void set_dash(Vec2 on_off) const noexcept;
|
|
/// `u_aa`: the AA fringe half-width in pixels. The style's `line_aa_px` in
|
|
/// device pixels, clamped at 0.25; 1.0 reproduces the historical fringe.
|
|
void set_aa(f32 px) const noexcept;
|
|
/// `u_color`: stroke colour, alpha included.
|
|
void set_color(Color color) const noexcept;
|
|
/// `u_snap`: with it on, an **axis-aligned** segment's ink is rounded onto whole
|
|
/// pixels along the axis it is constant on, so a hairline lights one column (or
|
|
/// row) fully instead of two at half coverage. It is for the chrome that frames a
|
|
/// plot -- grid lines, axis lines, panel and legend borders. Anything that reports
|
|
/// a data position -- a trace, a cursor, a region edge, the crosshair -- leaves it
|
|
/// off, because the rounding moves a line by up to half a pixel. A diagonal segment
|
|
/// is untouched whatever this says.
|
|
void set_snap(bool on) const noexcept;
|
|
|
|
private:
|
|
gl::Program program_;
|
|
};
|
|
|
|
/// Linked text program and its uniform surface. It fails exactly the way
|
|
/// `LineProgram::create()` does, propagating `Unsupported` and `GLFailure`.
|
|
///
|
|
/// `create()` also points the `u_atlas` sampler at texture unit 0, which is the
|
|
/// unit `plot::gl::Texture::bind()` defaults to, and leaves this program bound.
|
|
/// The atlas itself stays with the caller, who owns its lifetime.
|
|
class TextProgram {
|
|
public:
|
|
bool create(Status* st = nullptr) noexcept;
|
|
bool valid() const noexcept { return program_.id() != 0; }
|
|
void bind() const noexcept { program_.use(); }
|
|
|
|
/// `u_viewport`: render target size in pixels.
|
|
void set_viewport(Vec2 px) const noexcept;
|
|
/// `u_px_range`: the glyph cell's size on screen, in pixels (width and
|
|
/// height -- a cell need not be square).
|
|
void set_px_range(Vec2 px) const noexcept;
|
|
/// `u_glyph_uv`: the glyph cell's size in the atlas, normalised. It is the
|
|
/// rect every staged glyph is read through, so it is one size per draw -- and
|
|
/// it is the *backend's* (`TextBackend::cell_uv`), never a glyph's, because a
|
|
/// draw may stage glyphs whose origins differ even when their size cannot.
|
|
void set_glyph_uv(Vec2 uv) const noexcept;
|
|
/// `u_tex_size`: atlas size in texels.
|
|
void set_texture_size(Vec2 texels) const noexcept;
|
|
/// The tint is per instance (`a_colour`), not a uniform, so a draw can carry
|
|
/// runs of several colours -- there is deliberately no colour setter here.
|
|
|
|
private:
|
|
gl::Program program_;
|
|
};
|
|
|
|
/// Linked phosphor-density program and its uniform surface: one textured quad over a plot's
|
|
/// axes rect. It fails exactly the way the two above do, propagating `Unsupported` and
|
|
/// `GLFailure`.
|
|
///
|
|
/// It is the one pipeline with **no vertex data**: the quad's four corners come from
|
|
/// `gl_VertexID`, so a draw is one four-vertex strip whatever the grid's size and there is no
|
|
/// buffer to stage or upload. The density itself reaches the GPU as a texture -- one texel per
|
|
/// cell -- which is the one thing this pipeline has that the others do not.
|
|
///
|
|
/// `create()` also points the `u_density` sampler at texture unit 0, which is the unit
|
|
/// `plot::gl::Texture::bind()` defaults to, and leaves this program bound. The texture stays
|
|
/// with the caller, who owns its lifetime.
|
|
class DensityProgram {
|
|
public:
|
|
bool create(Status* st = nullptr) noexcept;
|
|
bool valid() const noexcept { return program_.id() != 0; }
|
|
void bind() const noexcept { program_.use(); }
|
|
|
|
/// `u_viewport`: render target size in pixels.
|
|
void set_viewport(Vec2 px) const noexcept;
|
|
/// `u_origin` and `u_size`: the quad in `Rect` pixels -- the axes rect's top-left corner and its
|
|
/// size, which is the area the image is drawn over (its own grid may hold fewer cells than the
|
|
/// rect has pixels: see `kDensityCellCap`). They are two uniforms rather than a rect because a
|
|
/// `vec4` uniform would need a fourth setter shape for one caller; a corner and a size are what
|
|
/// the vertex shader builds the quad from anyway.
|
|
void set_rect(Vec2 origin, Vec2 size) const noexcept;
|
|
/// `u_color`: the tint the cells' luminances are multiplied into.
|
|
void set_color(Color color) const noexcept;
|
|
|
|
private:
|
|
gl::Program program_;
|
|
};
|
|
|
|
} // namespace plot::render
|