- demo_buffer_set_features() sets global features for hb_shape
- web_set_features() wasm export parses comma-separated features
- Shell message handler accepts { kind: "features", value }
- Features applied to all shape calls in demo_buffer_add_text
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Allows the host page to simulate keypresses (e.g. 'b' for
dark mode toggle) via postMessage { kind: 'key', value }.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
EM_ASM stringifies its body, but the C tokenizer still parses
single-quoted '' as an empty char constant. Use double-quoted
"" -- valid JS empty string, no warning.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The previous palette commit added the C entry point and the
shell.html message handler but forgot to list _web_set_palette
in EXPORTED_FUNCTIONS, so emscripten dead-stripped it and the
'palette' postMessage was a silent no-op in the iframe.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Add web_set_palette() to both GL and WebGPU bindings (forwards
to demo_font_set_palette + buffer rebuild) and accept a
{ kind: 'palette', value: <int> } message in shell.html. Lets
the harfbuzz-world.cc host page push the user's CPAL pick into
the embedded GPU iframe alongside text / font / variations.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Add web_set_variations(const char *) to both the WebGL and
WebGPU hb-gpu-web wasm modules. Parses a comma-separated
"wght=400,wdth=100" string via hb_variation_from_string,
applies via hb_font_set_variations on the current font, and
rebuilds the shaping buffer. Cheap to call repeatedly --
suitable for live slider pushes once a slider UI lands.
Shell.html grows a matching applyVariations() helper and a
'variations' postMessage case. config-override.h undefs
HB_NO_VAR so the new function actually links. EXPORTED
_FUNCTIONS on both build scripts list _web_set_variations.
Also plumbed in a small cap (32 axes) on the stack so the
parser doesn't need hb's internal containers -- no font has
anywhere near that many.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The iframe-hosted case ran resizeCanvas() at script parse
time, before the iframe had laid out its canvas, which
installed a 0x0 drawing buffer. getContext('webgl2')
grabbed that 0x0 context and every subsequent setup (atlas,
viewport, swap chain) was frozen at 0x0 even when
ResizeObserver later re-ran resizeCanvas with real dims --
the existing context doesn't resize with the canvas
attribute.
Bail out of resizeCanvas when either dimension is 0, so the
canvas keeps its intrinsic default (300x150) until a real
layout arrives. getContext then grabs a non-degenerate
context, and the first ResizeObserver callback bumps it up
to the actual iframe-sized buffer.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Changing canvas.width/height directly doesn't reach
emscripten's GLFW port -- its framebuffer-size callback
fires on window 'resize' events, not canvas mutation
records. When ResizeObserver picks up the iframe's first
real layout, also dispatch a synthetic 'resize' event so
the framebuffer_size callback runs in wasm and glViewport
gets re-set to the real size.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Initial resizeCanvas() runs at script parse time -- when the
shell is inside a just-mounted iframe, the canvas's
clientWidth / clientHeight are 0 (iframe hasn't laid out
yet) and the GL drawing buffer installs at 0x0. A plain
window 'resize' event never fires just because the iframe
has sized itself, so the buffer stays 0x0 and the tab looks
blank forever.
Watch the canvas with a ResizeObserver and re-run
resizeCanvas + requestRedraw on any observed size change,
which catches the first real size the moment the iframe
lays out.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Be permissive about the embed-mode URL form: ?embed,
?embed=1, ?embed=true all turn the mode on; only explicit
?embed=0 / ?embed=false leave it off.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Lets a host page embed hb-gpu-demo as an iframe and drive it
from outside. harfbuzz-world.cc uses this to share its
text/font controls with the GPU tab without reinventing the
GPU stack.
Shell additions:
- ?embed=1 URL param hides the demo's own chrome (font
picker, text button, backend selector, FPS counter,
keyboard-help overlay) by setting html.embed.
- Message protocol:
{ kind: 'text', value: '…' } -> applyText
{ kind: 'font', bytes: ArrayBuffer } -> _web_load_font
On runtime init the shell posts { kind: 'ready' } to its
parent so the host can send font bytes (which can't ride
on the URL for file-uploaded fonts).
Existing ?text= and ?font= URL params still work and are
useful for "link to a specific demo" sharing.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Matches the GLSL convention: demo-shader.{msl,hlsl,wgsl} live
alongside demo-fragment.glsl and get stringified by the same
gen-gpu-shader-artifacts.py helper into demo-shader-{msl,hlsl,
wgsl}.hh. No more giant inline R"msl(...)" / R"hlsl(...)" /
R"wgsl(...)" blobs in the .mm / .cc files.
Each language combines vertex and fragment entry points in one
source, as is idiomatic for MSL / HLSL / WGSL compilers; GLSL's
split (demo-vertex.glsl + demo-fragment.glsl) is preserved
because glCompileShader takes separate stages.
No functional change.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The demo fragment shaders were passing u_foreground's brightness
to hb_gpu_stem_darken(), which was wrong for color glyphs: a red
cheek on an emoji should darken relative to its own red, not to
whatever the text-foreground uniform happens to be.
Switch all four demo fragment paths (GL, Metal, D3D11, WebGPU)
to compute brightness from the fragment's own straight color
(c.rgb / c.a). For monochrome glyphs this is identical to the
old formula -- the synthesized single layer's color IS the
foreground uniform -- so non-color rendering is unchanged.
The public hb_gpu_stem_darken() helper is unchanged; only its
callers pass a different brightness. Document the paint-path
usage in the hb-gpu section.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Adds command-line flags --draw (force monochrome Slug path) and
--paint (force COLRv1 paint path) to hb-gpu, defaulting to
auto-detect based on hb_ot_color_has_paint(face). Threads a
draw_only bool through the demo layer so each backend compiles
exactly one fragment program (draw or paint, not both).
The paint pipeline is ~10x slower than the draw pipeline on
monochrome content; auto-detect lets monochrome fonts keep the
fast path while still exercising both code paths from the same
binary.
Plumbing:
- demo_renderer_create_{gl,metal,d3d11} and demo_font_create
take a draw_only argument.
- demo-fragment.{glsl,msl,hlsl} branch on HB_GPU_DEMO_DRAW,
calling either hb_gpu_draw or hb_gpu_paint.
- demo-shader / glstate / d3d11 / metal include only the
fragment helper for the chosen path and prepend
HB_GPU_DEMO_DRAW to the source when draw_only.
- demo-font dispatches glyph upload to hb_gpu_draw_* or
hb_gpu_paint_* and hides palette/foreground setters in
draw mode.
Web demos pass false (paint-only) for now; a runtime
re-creation hook on font change would be needed there.
Tested on desktop GL, win64 D3D11, WebGL, WebGPU.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The `g` key was removed when we hardcoded gamma 2.2; the shell's
help overlay still mentioned it. Drop the lines.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The paint encoder bakes sRGB-encoded font palette values directly
(quantizing 0..255 to 0..32767 without decoding), so the shader
writes sRGB-ish values. With GL_FRAMEBUFFER_SRGB enabled the
driver then applied linear->sRGB encoding on store, giving a
double-encoded, washed-out result -- most visible on mid-tone
gradients.
The cleanest fix is to stop pretending we're doing linear-space
compositing: drop the sRGB framebuffer mode entirely and always
apply the classic 2.2 gamma exponent for coverage correction
(flipped to 1/2.2 in dark mode to match the existing light/dark
logic). Removed pieces:
- demo_view_t::gamma_mode enum, demo_view_set_gamma_mode,
demo_view_cycle_gamma, and the `g` keybinding + help line
- demo_renderer_t::set_srgb virtual + every backend override
- GLFW_SRGB_CAPABLE hint in gpu-output.hh
- Metal swapchain MTLPixelFormatBGRA8Unorm_sRGB -> BGRA8Unorm
Replaced with demo_view_update_gamma, called on setup() and after
the dark-mode toggle. Shader side stays the same (only alpha gets
the gamma curve, as before).
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Colors are now baked into encoded blobs (see prior commit), so
nothing needs to upload or bind a palette buffer. Remove
demo_renderer_t::set_palette from all backends (GL, Metal, D3D11,
WebGPU), the hb_gpu_palette GL uniform plumbing in demo-glstate,
the Metal/D3D11 palette buffers, and the WebGPU storage buffer +
bind-group entry. demo_font_get_palette is also gone.
Replace with new demo_font accessors that forward to the encoder:
demo_font_set_palette
demo_font_set_foreground
demo_font_clear_custom_palette_colors
demo_font_set_custom_palette_color
Each invalidates the glyph cache because colors are baked into
the atlas entries. gpu-output.hh now forwards view-option
--font-palette / --custom-palette through these.
Web demos stop allocating / uploading the palette buffer; the
WGSL fragment shader drops its third bind-group slot.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
rebuild_buffer did free(current_text); strdup(text); but was often
called with text == current_text (from web_load_font's
"custom_text ? current_text : default"). Strdup of freed memory
shaped garbage and made multi-char strings look like 1 char. Fix:
strdup first, then free.
The WebGL rebuild_buffer also called demo_view_display itself,
which runs fine from a main loop tick but not from a fetch
promise's microtask (the canvas back-buffer doesn't swap). Drop
it: demo_view_reset sets needs_redraw=true, and the next
main_loop_iter renders inside a proper rAF tick.
Emscripten allocates argv on the JS stack, which is unwound when
main returns. WebGPU's init is async and reads arg_text/arg_font
after main returns, so those pointers were dangling -- early null
bytes in freed stack memory made the emoji URL shape to 1 glyph.
strdup them in main so they survive.
Finally, forward ?font= to argv as --font= (already done for
?text=) so the C side's "skip initial default-font glyph upload
when a font fetch is pending" path actually triggers.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Three small UX improvements to the web demos.
### Skip default-font upload when ?font= is pending
When ?font= is set, the async fetch replaces the font later. main
was still populating the atlas with the default font's glyphs for
the initial text, just to throw them away when _web_load_font ran
its own rebuild_buffer. Gate demo_buffer_add_text() on !arg_font
so the buffer stays empty until the real font lands.
### WebGPU ready signal
WebGPU's init_demo is async (awaits adapter/device), so
onRuntimeInitialized fires before the demo is usable; calling
_web_load_font from the ?font= fetch at that point tripped a wasm
indirect-call signature mismatch. init_demo now EM_ASMs a
window._webDemoReady() hook at its tail; the shell installs
_webDemoReady = startFontFetch when running the WebGPU build and
starts the fetch immediately for WebGL.
### URL ergonomics
* Backend-selector change now carries location.search across the
navigation -- ?text= and ?font= survive the WebGL <-> WebGPU
switch.
* The text-edit modal's Apply button updates history.replaceState
with a ?text= param so the typed text is copy/pasteable. Skips
the update when the text is unchanged from what was open.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Two user-visible features plus a font swap.
### URL parameters
Forwards ?text= and ?font= from the query string into the C main
as --text=... and --font=... via Module.arguments, so the initial
text is applied before the first rendered frame (no flash of
default demo text). ?font= is still fetched asynchronously on
the JS side; once loaded, the text is re-applied to the new font.
If neither parameter is present, behaviour is unchanged: the
baked-in default text renders in the baked-in default font.
Data URLs (?font=data:font/ttf;base64,...) work naturally via
fetch(). Remote URLs need CORS; raw.githubusercontent.com and
jsdelivr both work, github.com/.../raw/... does not.
### Wider default font
The baked-in default-font.hh was a narrow subset that didn't
include uppercase Latin, so `?text=Hello` shaped to .notdef for
H and W. Re-subset Parastoo-Regular.ttf via hb-subset with:
--unicodes='U+0020-007E,U+0600-06FF,U+FB50-FDFF,U+FE70-FEFF'
covering printable ASCII plus the Arabic block and the two
Arabic presentation-forms blocks.
Font size:
source Parastoo-Regular.ttf 109152
new subset 49940
Wasm size impact (webgl build, Oz+lto):
before 443628 181597 gz
after 466657 196209 gz
delta +23029 +14612 gz
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Wires view_options_t into gpu_output_t so hb-gpu picks up the
same foreground/background/palette flags the rest of the tools
use:
--foreground=#RRGGBB[AA]
--background=#RRGGBB[AA]
--font-palette=N
--custom-palette=N=#RRGGBB[,N=#RRGGBB,...]
After demo_view_setup() the gpu main loop now:
1. Fetches the active palette from the face via
demo_font_get_palette(font, view.palette, ...) -- palette index
out of range falls back to 0.
2. Overlays each view.custom_palette_entries entry on top of that
palette (clamped to 256 entries).
3. Uploads via renderer->set_palette(). Web demos and the
headless WebGPU path do the same, with palette_index=0 (they
don't yet plumb --font-palette).
4. Calls renderer->set_foreground / _background from the
post-parsed view-options colours. Defaults match the demo's
prior LIGHT mode, so no-op when the user passes no flags; the
dark-mode toggle (b key) still mutates renderer state
independently.
Other view-options flags (--rainbow, --stroke, --line-space,
--margin, --logical/--ink, --show-extents, --font-extents)
appear in --help-view for familiarity but currently no-op in
hb-gpu; they're inherited wholesale from view_options_t and the
gpu path just doesn't wire them.
demo_font_get_palette() now takes a palette_index parameter so
callers can ask for non-zero palettes (e.g. dark-mode palettes in
fonts that ship them). Web demos pass 0 for now.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Reorganises the palette-upload plumbing so every backend handles
it uniformly and the hacky atlas-backend palette callback goes
away.
Before: demo_font_upload_palette in demo-font.cc mixed a GL
glUniform4fv direct call with a detour through an extra
demo_atlas_backend_t.upload_palette callback used by the Metal
renderer. demo-font and demo-atlas both knew about palettes.
After:
* demo_font_get_palette (font, out, capacity) just reports the
active palette as RGBA floats; demo-font no longer touches GL
state or the atlas for palettes.
* demo_renderer_t gains a virtual set_palette (rgba, count).
Default is a no-op. Backends override:
- demo-renderer-gl.cc -> demo_glstate_set_palette() ->
glUniform4fv.
- demo-metal.mm -> memcpy into the MTLBuffer's contents.
- demo-renderer-d3d11.cc -> ID3D11DeviceContext::UpdateSubresource
(palette buffer switched from IMMUTABLE to DEFAULT).
- hb-gpu-web-webgpu.cc -> wgpuQueueWriteBuffer on the palette
storage buffer.
* Callers invoke renderer->set_palette (palette, n) right after
demo_font_create:
- util/gpu-output.hh (desktop demo: GL / Metal / D3D11).
- util/gpu/web/hb-gpu-web.cc (WebGL).
- util/gpu/web/hb-gpu-web-webgpu.cc (WebGPU).
* The extra upload_palette field on demo_atlas_backend_t is
removed along with demo_atlas_upload_palette / _is_external --
atlas is back to being about glyph data only.
COLRv0 rendering now works with proper palette colours through
every backend that implements set_palette (WebGL, WebGPU, and
Metal/D3D11 once tested).
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit unblocks end-to-end paint rendering on the WebGPU
demo, adds the HLSL port, and avoids losing MSAA or stem
darkening along the way.
### Shared: _hb_gpu_draw_impl
hb_gpu_draw internally did fwidth(renderCoord) + MSAA. That works
fine in the single-call-per-fragment case but not when called from
inside a non-uniform branch (e.g. an op-stream LAYER_SOLID
conditional in the paint fragment shader) -- WGSL rejects fwidth
from non-uniform control flow.
Factor the MSAA-aware body into _hb_gpu_draw_impl, which takes a
caller-supplied pixelsPerEm. hb_gpu_draw is now a thin wrapper
that computes pixelsPerEm via fwidth and delegates. The paint
fragment shader in every language now computes pixelsPerEm once
at the top of hb_gpu_paint and calls _hb_gpu_draw_impl per layer
-- MSAA preserved, no redundant fwidth calls per layer.
In WGSL, _hb_gpu_draw_impl also inlines the ppem computation from
pixelsPerEm rather than recurring into hb_gpu_ppem (which itself
calls fwidth).
### Paint shaders
- hb-gpu-paint-fragment.hlsl (new): HLSL transcription. Assumes
a caller-declared StructuredBuffer<float4> hb_gpu_palette at
register(t1).
- hb-gpu-paint-fragment.wgsl: switched from hb_gpu_draw to
_hb_gpu_draw_impl; comment updated.
- hb-gpu-paint-fragment.msl, .glsl: same switch, cached
pixelsPerEm at entry.
hb_gpu_paint_shader_source() now returns content for all four
languages.
### Demos
- util/gpu/demo-fragment.glsl: restores stem darkening (dropped in
the first paint wiring commit); applies to the premultiplied
RGBA by scaling both colour and alpha. The desktop GL demo
regenerates demo-fragment-glsl.hh from this source.
- util/gpu/web/hb-gpu-web-webgpu.cc: WGSL fs_main concatenates the
paint source, binds a zero-filled palette storage buffer at
@group(0) @binding(2), and restores stem darkening. fwidth
hoisted outside the stem-darkening conditional so WGSL's
derivative-uniformity rule is happy.
- util/gpu/demo-renderer-d3d11.cc: HLSL ps_main switches to
hb_gpu_paint. Adds a second StructuredBuffer<float4>
hb_gpu_palette at t1, zero-filled for now, bound alongside the
atlas SRV.
### Misc
- perf/benchmark-gpu.cc: fix stale reset/encode(draw) calls.
Measured build (local Emscripten):
WebGL index.wasm : 443638 181640 gz
WebGPU webgpu.wasm : 461626 188400 gz
COLRv0 rendering (BungeeTint, Noto Color Emoji, etc.) now works
end-to-end on WebGL and WebGPU with the correct palette. Metal
and D3D11 demos should likewise compile against the new shader
flow; real palette upload cross-backend remains a TODO.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
WGSL transcription of the paint interpreter. Takes the atlas and
palette as explicit storage-buffer pointer parameters (matching
the WGSL draw helper's calling convention):
fn hb_gpu_paint (renderCoord: vec2f, glyphLoc: u32,
foreground: vec4f,
hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>,
hb_gpu_palette: ptr<storage, array<vec4f>, read>) -> vec4f
hb_gpu_paint_shader_source() now returns real content for
HB_GPU_SHADER_LANG_WGSL fragment; HLSL still stubs to "".
util/gpu/web/hb-gpu-web-webgpu.cc:
- Concats the paint source alongside the draw source into the
WGSL shader module.
- Declares @group(0) @binding(2) for hb_gpu_palette.
- Allocates a 256 * vec4f storage buffer (zero-filled for now;
real palette upload is TODO), binds it at entry index 2.
- Fragment main switches from hb_gpu_draw to hb_gpu_paint.
util/gpu/web/gl-stub.h: adds glUniform4fv stub (demo-font.cc now
calls it for the GL palette path) and makes
glGetUniformLocation return -1 so the WebGPU build's
demo_font_upload_palette short-circuits.
Wasm sizes:
WebGL index.wasm : 443628 181597 gz
WebGPU webgpu.wasm : 461110 188045 gz
Non-color text should render through WebGPU. COLRv0 color glyphs
come up transparent until the cross-backend palette upload lands.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Wire the paint-callback pipeline for COLRv0 color glyphs.
Adds:
* push_clip_glyph / pop_clip / color / custom_palette_color
callbacks. Each COLRv0 layer's push_clip_glyph is captured,
then the following color callback rasterizes the clip-glyph
outline through a scratch hb_gpu_draw_t, appends the resulting
Slug sub-blob, and emits a LAYER_SOLID op carrying the
palette_index (preserved via custom_palette_color) plus the
is_foreground flag. pop_clip clears the pending state.
* hb_gpu_paint_get_funcs(): cached singleton hb_paint_funcs_t via
the standard hb_paint_funcs_lazy_loader_t.
* hb_gpu_paint_glyph(): stashes the font scale and invokes
hb_font_paint_glyph_or_fail() with our funcs and a sentinel
foreground (the encoder never stores foreground -- the shader
resolves it per quad from a caller-supplied attribute).
* hb_gpu_paint_encode(): concatenates the 3-texel header, the op
stream, and the collected sub-blobs into one RGBA16I blob,
patching each op's sub_blob-index into an absolute texel
offset. Returns NULL when no layers accumulated or an
unsupported (v1) feature was seen.
* hb_gpu_paint_clear(): discards ops, sub-blobs, and pending
state while preserving the font scale.
The gradient / group / transform callbacks are not wired yet, so
COLRv1 paint graphs silently fall through -- callers should
precheck with hb_ot_color_glyph_has_paint() and route v1 glyphs
elsewhere (or fall back to draw).
Enables HB_NO_COLOR and HB_NO_PAINT in the web demo config
override so the wasm link resolves the new paint pipeline
symbols. Measured on a local Emscripten build:
raw wasm: 412722 -> 437752 (+25030 B, +6.1%)
gzip wasm: 170342 -> 179165 ( +8823 B, +5.2%)
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The draw-renderer fragment shaders defined utilities
(HB_GPU_UNITS_PER_EM, the hb_gpu_atlas uniform, hb_gpu_fetch) that
any future GPU renderer will also need. The draw-renderer vertex
shader likewise contained only the generic hb_gpu_dilate helper.
If a paint renderer were added today and a caller linked both
fragment sources together, hb_gpu_fetch would be defined twice.
Move these shared helpers into a new family of sources and expose
them via a new public entry point:
hb_gpu_shader_source (stage, lang);
The existing hb_gpu_draw_shader_source() now returns only the
draw-specific fragment code; it returns an empty string for the
vertex stage because all current vertex logic is shared. Callers
concatenate the shared source first, then the draw-specific
source, then their own main():
[#version, hb_gpu_shader_source (...), hb_gpu_draw_shader_source
(...), main]
Additions:
- src/hb-gpu-fragment.{glsl,msl,wgsl,hlsl} — shared fragment
- src/hb-gpu-vertex.{glsl,msl,wgsl,hlsl} — shared vertex,
renamed from hb-gpu-draw-vertex.*
- src/hb-gpu-shaders.cc — hb_gpu_shader_source() dispatcher
Removals:
- src/hb-gpu-draw-vertex.{glsl,msl,wgsl,hlsl} — moved to common
Shared sources are Behdad-only copyright; the Eric Lengyel / Slug
attribution stays on the draw-specific fragment sources where the
Slug algorithm actually lives.
Updates: test/api/test-gpu.cc, the Metal/D3D11/WebGPU/GL demo
shaders, the hb-gpu SECTION documentation, meson.build,
CMakeLists.txt, gen-gpu-shader-artifacts.py decl_map,
harfbuzz-world.cc, and docs/harfbuzz-sections.txt.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The previous commit renamed hb_gpu_darken to hb_gpu_draw_darken
for symmetry with hb_gpu_draw (formerly hb_gpu_render). But the
operation isn't draw-subsystem specific: it adjusts a coverage
value based on foreground brightness and ppem, which is just the
standard stem-darkening recipe. Name it after what it does.
Paint doesn't need its own variant — it can call this same
function on any alpha/coverage channel it produces.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Rename the public fragment-shader entry points provided by the
hb_gpu_draw_t renderer:
hb_gpu_render(...) -> hb_gpu_draw(...)
hb_gpu_darken(...) -> hb_gpu_draw_darken(...)
Also rename the internal helper:
_hb_gpu_render_single(...) -> _hb_gpu_draw_single(...)
A COLRv1 paint renderer is planned and will provide its own
fragment entry point (likely hb_gpu_paint returning a vec4); the
existing draw/coverage entry point gets a subsystem-qualified name
now so draw and paint can coexist.
Updates the .glsl/.msl/.wgsl/.hlsl sources, regenerated .hh
artifacts, the documentation block in hb-gpu.cc, and the util/gpu
demo shaders. No behavior change.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Replace the two separate getters
hb_gpu_shader_fragment_source (lang)
hb_gpu_shader_vertex_source (lang)
with a single
hb_gpu_draw_shader_source (stage, lang)
where stage is the new hb_gpu_shader_stage_t enum (VERTEX or
FRAGMENT). Parameter order is stage-first because "the vertex
shader in GLSL" reads more naturally than the reverse, and stage
is the primary axis (it determines which shader object the source
is compiled into).
The `_draw_` in the new name makes room for the incoming
hb_gpu_paint_shader_source() once the COLRv1 encoder lands —
that family will have its own (likely different) shader sources
per stage and language.
Updated the four in-tree callers: test/api/test-gpu.cc, and the
GPU demos under util/gpu/. ABI break on a 14.0-only API; the
gpu library is still young enough that this is acceptable.
Marked new API with XSince: REPLACEME.
Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Check navigator.gpu synchronously in main() before calling
the WebGPU C API. Previously the error was reported in an
async callback that raced with onRuntimeInitialized, which
hid the loading div before the error message could appear.
Also re-show the loading div and set window._webgpuError in
the adapter callback as a fallback.
Assisted-by: Claude <noreply@anthropic.com>
The GL renderer cached the vertex buffer upload by comparing
the data pointer and count. After clearing and refilling the
buffer with a new font's glyphs, std::vector reused the same
allocation, so the pointer and count matched — the upload was
skipped and the GPU drew with stale vertex data containing old
atlas offsets.
Fix by adding a generation counter to demo_buffer_t that
increments on clear(). The renderer compares generation and
count to decide whether to re-upload.
Assisted-by: Claude <noreply@anthropic.com>
Add config.h with HB_LEAN and config-override.h to re-enable
draw, metrics, and variable font support. Strips color, paint,
math, bitmap, deprecated APIs, and other unused features.
WebGL: 635KB → 513KB (-19%)
WebGPU: 655KB → 533KB (-19%)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Library function for stem darkening: pow(2, brightness-0.5)
scaled by ppem. Added to GLSL, MSL, WGSL, HLSL with consistent
brief docs. Demo shaders now call the library function.
Section docs in hb-gpu.cc updated with usage example.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Replace boolean light_on_dark with continuous brightness-driven
exponent. pow(2, b-0.5) gives sqrt(2)≈1.414 for white text
(thin) and 1/sqrt(2)≈0.707 for black text (fatten), perfectly
symmetric around 1.0 at 50% gray.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
The WebGPU touch path was still using the older gesture state machine.
It handled 3->2 reseeding, but it did not track whether a pinch was
active and it had no explicit 2->1 single-finger pan handoff.
Carry over the proven transition rules from the WebGL path without
changing desktop input handling: track pinch-active and synthetic
single-pan state, preserve the 3->2 reseed, and continue pan after a
pinch when one finger remains. touchcancel now also clears those touch
states consistently.
Testing:
- source /home/behdad/emsdk/emsdk_env.sh >/dev/null &&
EM_CACHE=/tmp/emscripten-cache ./util/gpu/web/build.sh
- source /home/behdad/emsdk/emsdk_env.sh >/dev/null &&
EM_CACHE=/tmp/emscripten-cache ./util/gpu/web/build-webgpu.sh
Assisted-by: OpenAI Codex
The previous fix stopped the 2->1 jump by swallowing the pinch-ending
touchend and seeding a synthetic left-button press at the remaining
finger. But subsequent one-finger motion was still left to the browser,
which does not reliably resume mouse emulation mid-gesture.
Track an explicit single-finger pan mode after the pinch handoff, route
its touchmove events to synthetic mousemove, and end it with a
gesture-cancelled synthetic mouseup on lift or touchcancel.
Testing:
- source /home/behdad/emsdk/emsdk_env.sh >/dev/null &&
EM_CACHE=/tmp/emscripten-cache ./util/gpu/web/build.sh
- source /home/behdad/emsdk/emsdk_env.sh >/dev/null &&
EM_CACHE=/tmp/emscripten-cache ./util/gpu/web/build-webgpu.sh
Assisted-by: OpenAI Codex
The WebGL touch path only tracked the initial 3->2 reseed with
skipNextPinchMove. Once a real pinch was underway, the later 2->1
transition stopped being treated as a gesture handoff and fell back
into the browser/GLFW single-touch path.
Track pinch-active state explicitly, swallow the pinch-ending touchend,
and hand single-finger pan off from the remaining touch by syncing the
cursor before synthesizing mousedown. This keeps the 3->2->1 sequence
from jumping the view when the second finger lifts.
Testing:
- source /home/behdad/emsdk/emsdk_env.sh >/dev/null &&
EM_CACHE=/tmp/emscripten-cache ./util/gpu/web/build.sh
- source /home/behdad/emsdk/emsdk_env.sh >/dev/null &&
EM_CACHE=/tmp/emscripten-cache ./util/gpu/web/build-webgpu.sh
Assisted-by: OpenAI Codex
Dispatch mousemove before mousedown when transitioning from
pinch to single-finger pan, so GLFW's cursor position matches
the remaining finger.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Double-left-click and double-right-click both reset view.
Middle-click reset also still works. Updated help text.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
GLFW doesn't see the remaining finger after a swallowed pinch,
so synthesize a mousedown to start drag tracking.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
WebGL mobile currently commits a tap on touchstart, then the second
tap in a double-tap zoom has to undo that animation toggle. This
makes tap and double-tap drag compete and can start animation before
gesture intent is clear.
Track a pending single tap until touchend, suppress the synthetic
click toggle on release, and only fire the animation toggle after the
double-tap timeout expires. A second tap now cancels that pending
toggle and claims double-tap zoom directly.
Testing:
- source /home/behdad/emsdk/emsdk_env.sh >/dev/null &&
EM_CACHE=/tmp/emscripten-cache ./util/gpu/web/build.sh
- source /home/behdad/emsdk/emsdk_env.sh >/dev/null &&
EM_CACHE=/tmp/emscripten-cache ./util/gpu/web/build-webgpu.sh
Assisted-by: OpenAI Codex