Commit Graph
20960 Commits
Author SHA1 Message Date
Behdad Esfahbod 30ee1bb2c6 [vector] Rename hb_vector_svg_*set_{flat,precision} API
Drop "svg" from the names since flat/precision settings apply
equally to PDF output.  The new names follow the hb_vector_draw_*
/ hb_vector_paint_* convention:

  hb_vector_svg_set_flat         -> hb_vector_draw_set_flat
  hb_vector_svg_set_precision    -> hb_vector_draw_set_precision
  hb_vector_svg_paint_set_flat   -> hb_vector_paint_set_flat
  hb_vector_svg_paint_set_precision -> hb_vector_paint_set_precision

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-10 12:16:55 -06:00
Behdad Esfahbod 0967927b88 [vector] Extract shared sweep gradient tiling logic
Move the sweep gradient color stop tiling (pad/repeat/reflect
across 0-2π) into a shared template hb_sweep_gradient_tiles()
in hb-vector-svg-utils.hh.  Both SVG and PDF backends now call
it with their own patch emitter callback.

Also adds hb_color_lerp() to the shared header (fixing an R/B
channel swap bug in the PDF version's interpolation).

Net reduction of ~170 lines of duplicated tiling code.

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod d80e1da9cd [vector] Implement PDF PNG image embedding with transparency
Add PNG image support to the PDF paint backend. Parses PNG chunks
to extract IHDR metadata and IDAT compressed data, then embeds
directly as PDF XObject Image with /FlateDecode and /Predictor 15
(PNG predictor), avoiding any re-encoding of pixel data.

Supports:
- Grayscale, RGB, Gray+Alpha, RGBA (8-bit)
- Indexed color (palette PNG) via /Indexed colorspace with PLTE
- Transparency for indexed PNG via SMask: decompresses IDAT,
  un-filters PNG rows, maps palette indices to tRNS alpha values,
  and emits a separate DeviceGray soft mask image

Tested with NotoColorEmoji.ttf (CBDT, indexed PNG with partial
alpha) and sbix.ttf (SBIX, RGBA PNG).

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 184b5bb7c3 [vector] Implement PDF blend modes via push_group_for
Use the new push_group_for API to emit PDF ExtGState with /BM
(blend mode) when the compositing mode has a PDF 1.4 equivalent.

Maps 15 blend modes: Multiply, Screen, Overlay, Darken, Lighten,
ColorDodge, ColorBurn, HardLight, SoftLight, Difference, Exclusion,
Hue, Saturation, Color, Luminosity.

Porter-Duff modes (Clear, Src, Dst, etc.) have no direct PDF /BM
equivalent and fall back to the default (Normal/SrcOver).

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 1141e97ef4 [paint] Add hb_paint_push_group_for() API
Add a new push_group variant that receives the compositing mode
upfront. This lets backends like PDF emit blend-mode state before
painting the group content, avoiding the need to buffer and
retroactively wrap.

The default (nil) implementation calls hb_paint_push_group(), so
existing backends are unaffected.

Callers updated:
- COLR PaintComposite now calls push_group_for() for both groups
- Rust/fontations push_layer passes the mode through
- hb-raster SVG context accepts mode parameter (default SRC_OVER)

All 233 tests pass.

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 39f622285e [vector] Fix PDF sweep gradient to tile across full circle
The previous implementation only covered start_angle to end_angle
with a fixed number of equal sectors, which broke repeat/reflect
extend modes and produced too few patches for oscillating gradients.

Rewrite to use the same tiling logic as the SVG sweep gradient:
map color stops to angles, handle pad/repeat/reflect extend modes,
and tile across the full 0-2π range. Each color stop interval
becomes one Coons patch (further split at 90° max for arc quality).

Tested with sweep_270_440_reflect_narrow glyph from
test_glyphs-glyf_colr_1_variable.ttf.

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod c67c323d0b [vector] Rename hb_svg_append_* to hb_buf_append_*
The buffer helper functions (append_str, append_len, append_c,
append_num, append_unsigned, append_hex_byte, append_base64,
recover_recycled, blob_from) are format-agnostic and used by
both SVG and PDF backends.  Rename from hb_svg_* to hb_buf_*
to reflect this.

SVG-specific helpers (append_color, append_instance_transform,
transform_point, scale_precision, etc.) keep their hb_svg_*
names.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 4087416a68 [vector] Add hb-vector-pdf-paint.cc to harfbuzz-world.cc
Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 6abf48a9e5 [vector] Implement PDF sweep gradient via Type 6 Coons patches
Replace the pie-slice sector fallback with proper Type 6
Coons patch mesh shading.  Each sector of the sweep is a
patch with:
  - Outer arc approximated by cubic Bézier (kappa method)
  - Inner arc at small radius to avoid degenerate geometry
  - Radial straight edges connecting inner and outer
  - Corner colors from the color line at sector boundaries

Sectors are limited to 90° for accurate Bézier arc
approximation, with a minimum of 4 patches per sweep.

The mesh data is encoded as a binary stream with 16-bit
coordinates, 8-bit color components, and 8-bit flags per
the PDF Type 6 specification.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 4086e62808 [vector] Implement PDF sweep gradient via sector decomposition
Decompose sweep gradients into 360 colored pie-slice sectors.
Each sector evaluates the color line at its midpoint and emits
a filled triangular path from the center to two points on a
large-radius arc.

Includes a color line evaluator that handles pad, repeat, and
reflect extend modes with linear interpolation between stops.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 30be6b8b53 [vector] Add alpha, linear, and radial gradients to PDF paint
Rewrite hb-vector-pdf-paint.cc with a proper PDF object
system that supports dynamic resource generation:

Alpha:
  Solid colors with alpha < 1 now emit ExtGState objects
  with /ca (fill opacity) and reference them via /GSn gs
  in the content stream.

Gradients:
  Linear gradients → PDF Type 2 (axial) shading with
  Type 2/3 interpolation functions for color stops.
  Radial gradients → PDF Type 3 (radial) shading.
  Sweep gradients → solid fallback (no PDF equivalent).

Architecture:
  A hb_pdf_resources_t collector tracks extra PDF objects
  (ExtGState, Shading, Function) during painting.  At render
  time, these are emitted as numbered objects and referenced
  from the Page's Resources dictionary.

Mark internal symbols HB_INTERNAL to fix check-symbols test.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod e197c13f8b [vector] Fix PDF paint glyph Y-flip
Remove the -xy/-yy negation from the PDF paint glyph
positioning transform.  Font and PDF coordinates are both
Y-up, so no flip is needed.  Same fix as was applied to
the draw path earlier.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod e046d2ba6d [vector] Add PDF color font rendering via paint API
Add hb-vector-pdf-paint.cc with a complete set of PDF paint
callbacks for the HarfBuzz paint API:

  push/pop_transform  →  q + cm / Q
  push/pop_clip_glyph →  q + path + W n / Q
  push/pop_clip_rect  →  q + re + W n / Q
  color               →  rg + re + f
  push/pop_group      →  q / Q
  gradients           →  solid fallback (first stop color)

The PDF paint backend reuses the draw funcs for glyph clip
path emission and shares the hb_vector_paint_t struct with
the SVG backend via hb-vector-paint.hh.

hb_vector_paint_glyph dispatches to SVG or PDF paint funcs
based on format.  hb_vector_paint_render delegates to the
PDF render function for PDF output.

Tested with COLRv0 (RocherColorGX) — color layers render
correctly with proper clipping.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod d530482115 [vector] Extract hb_vector_paint_t to shared header
Move the paint struct and color glyph cache key to
hb-vector-paint.hh so the upcoming PDF paint backend can
share the type.  Convert the SVG-specific transform helper
methods to free functions.

No functional change.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod ca9f1f49cf [vector] Fix PDF pen position — no Y negation needed
The pen coordinates from vector-output.hh are in font space
(Y-up), not SVG space.  The Y-flip in compute_extents only
affects the extents, not the pen positions passed to
hb_vector_draw_glyph.  Use pen_y directly.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 0b91bb09fb [vector] Fix PDF coordinate system
Font and PDF coordinates are both Y-up, so no Y-flip is
needed in the path data.  The pen position from the SVG-space
layout is the only thing that needs negating.

Remove the Y negation from append_xy and the CTM from the
content stream.  Set the glyph transform to identity with
negated pen_y.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 4faf03e9e9 [vector] Fix PDF fill inversion by negating Y in coordinates
The previous CTM-based Y-flip reversed path winding, causing
inverted fills.  Instead, negate Y directly in append_xy for
PDF format.  This preserves winding direction and produces
correct non-zero fill results.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod 3fc9ae5e49 [vector] Fix PDF coordinate system with Y-flip CTM
Prepend a 1 0 0 -1 0 (ey+eh) cm to the content stream so
that the SVG-space (Y-down) path coordinates render correctly
in PDF (Y-up).  Set the MediaBox to [ex 0 ex+ew eh].

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
Behdad Esfahbod a43971d2a3 [vector] Add PDF output backend
Add HB_VECTOR_FORMAT_PDF to hb_vector_format_t.  The hb-vector
tool now produces self-contained PDF when invoked with -o out.pdf.

PDF path operators map directly from the draw callbacks:
move_to → m, line_to → l, cubic_to → c, close_path → h,
with quadratic-to-cubic promotion (PDF has no Q operator).

The render function builds a minimal PDF 1.4 with catalog,
page, and content stream objects plus a cross-reference table.

Implementation:
- Extract hb_vector_draw_t struct to hb-vector-draw.hh so
  future backends can share it.
- Draw callbacks branch on format for SVG vs PDF syntax.
- hb_vector_draw_glyph and hb_vector_draw_render dispatch by
  format.
- vector-output.hh selects format from file extension and
  skips paint (color glyphs) for PDF.

Coordinate system needs refinement — the page layout inherits
the SVG Y-flip transform, placing glyphs at the top with
extra whitespace.  Correct PDF coordinate handling is a
follow-up.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-07 20:12:59 -06:00
jfkthame 5cbce05a7c Add a couple of missing overflow checks (#5901)
* Use hb_unsigned_mul_overflows in CFF2 process_blend.

* Check for overflow when computing hb_aat_layout_chain_accelerator_t size.
2026-04-07 15:36:21 -06:00
Dominik Röttsches 6c5a137cb7 [rust] Make HarfRust' dependency on Draw/Paint optional. (#5900)
Add draw and paint features to font.rs. Enable both by default in
Cargo.toml. This allow compilation without draw and paint functionality
enabled on the C++ side.

Assisted-by: Gemini CLI
2026-04-07 12:38:19 -06:00
Behdad Esfahbod ee7c6dbde4 [CODE_OF_AI_CONDUCT] Require two reviews for large library changes (#5899) 2026-04-07 11:22:47 -06:00
Behdad Esfahbod a12f531ad1 [README.md] Format 2026-04-06 19:30:21 -06:00
Behdad Esfahbod 2b89ade7a1 [README.md] Auxiliary libraries 2026-04-06 18:13:17 -06:00
Behdad EsfahbodandOpenAI Codex 03c262d1eb [raster] Clamp reflected gradient LUT coordinates
Malformed reflected gradients can produce very large finite
gradient parameters. The raster backend normalized reflect
mode by casting floorf(t) to int, which can overflow and
drive LUT lookups past the fixed-size stack buffer.

Fold reflected coordinates with fmodf(), clamp LUT inputs
defensively, and add the minimized oss-fuzz raster
testcase to the corpus.

Fixes: https://oss-fuzz.com/testcase-detail/6597066439852032
Tested: meson test -C build
Co-Authored-By: OpenAI Codex <codex@openai.com>
2026-04-06 17:13:58 -06:00
Behdad Esfahbod 5ce0b12729 [CONFIG] Remove outdated note
Fixes https://github.com/harfbuzz/harfbuzz/issues/5890
2026-04-06 17:08:50 -06:00
dependabot[bot] cd095479dd Bump mymindstorm/setup-emsdk from 14 to 15
Bumps [mymindstorm/setup-emsdk](https://github.com/mymindstorm/setup-emsdk) from 14 to 15.
- [Release notes](https://github.com/mymindstorm/setup-emsdk/releases)
- [Commits](https://github.com/mymindstorm/setup-emsdk/compare/6ab9eb1bda2574c4ddb79809fc9247783eaf9021...667eb33f24e84e7f362c16d8d7fff0629a73e15e)

---
updated-dependencies:
- dependency-name: mymindstorm/setup-emsdk
  dependency-version: '15'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
2026-04-06 14:00:47 +02:00
Behdad Esfahbod 3b7ee09f0e [gpu] Fix draw encode blob ownership leaks
hb_gpu_draw_encode() could allocate a fresh output buffer and then
return NULL before transferring ownership to a blob, leaking that
temporary buffer on late encode failures.

The recycled-blob growth path also tried hb_realloc() first and fell
back to hb_malloc() when that failed. Once the new buffer was committed
to the recycled blob, the old recycled buffer could be orphaned.

Free temporary buffers on the remaining late-failure exits and keep
the old recycled buffer alive until a replacement has been committed.
Tighten the GPU API recycle test to encode a larger second outline so
that reused-buffer growth stays covered.

Tested:
- meson test -C build

Assisted-by: OpenAI Codex <codex@openai.com>
2026-04-04 19:44:54 -06:00
Khaled Hosny cfb70b0b91 14.1.0 14.1.0 2026-04-04 20:31:18 +02:00
Behdad Esfahbod 1519b54405 Merge pull request #5894 from harfbuzz/fuzzer-fixes-apr3
Fuzzer fixes apr3
2026-04-03 18:20:33 -06:00
Behdad Esfahbod e8c5bb452d [raster] Widen edge row interpolation arithmetic
edge_sweep_row() computed the clipped endpoint x coordinates with
int32_t subtractions before casting to int64_t. If an edge started at
INT32_MIN and the scanline clipped endpoint was near zero, ey - yL
overflowed before the slope multiply and UBSan flagged the raster
fuzzer path.

Keep the endpoint interpolation and follow-on dx math in 64-bit until
clamping back to int32_t. This preserves the existing rasterizer logic
while avoiding signed overflow for extreme edge coordinates.

Tested:
- meson test -C build

Assisted-by: OpenAI Codex <codex@openai.com>
2026-04-03 18:07:28 -06:00
Behdad Esfahbod 8395b30b5b [raster] Move PNG scratch state out of libpng longjmp locals
libpng aborts via longjmp. Our PNG read/write helpers kept scratch
hb_vector_t objects as automatic locals after setjmp and then tried
to free them from the longjmp handler. Once longjmp fires, those
modified locals have indeterminate state, so the cleanup path can
miss live allocations and leak under the raster fuzzer.

Move the PNG scratch buffers and write accumulator into explicit
heap-backed state allocated before setjmp and cleaned up on every
exit path. This keeps both decode and encode cleanup deterministic
across libpng errors.

Tested:
- env LD_LIBRARY_PATH=/home/behdad/harfbuzz/build/src valgrind --leak-check=full --show-leak-kinds=all --error-exitcode=1 ./build/test/fuzzing/hb-raster-fuzzer test/fuzzing/fonts/clusterfuzz-testcase-minimized-hb-subset-fuzzer-5684014636859392
- meson test -C build raster-fuzzer-chunk-0 raster-fuzzer-chunk-1 raster-fuzzer-chunk-2 raster-fuzzer-chunk-3 raster-fuzzer-chunk-4 raster-fuzzer-chunk-5 raster-fuzzer-chunk-6 raster-fuzzer-chunk-7 --wrap='valgrind --leak-check=full --show-leak-kinds=all --error-exitcode=1' --print-errorlogs
- meson test -C build

Assisted-by: OpenAI Codex <codex@openai.com>
2026-04-03 17:38:32 -06:00
Behdad Esfahbod ae23a9b5cb [raster] Fix transformed clip mask intersection bounds
Transformed clip rectangles kept their intersection math in unsigned
loop bounds after clamping only the lower edge to zero. When the
transformed upper edge stayed negative, the signed-to-unsigned cast
wrapped and raster clip reuse read past the previous alpha mask.

The same path also reused emitter-generated clip buffers without
clearing bytes outside the rows it rewrote, which let Valgrind see
uninitialized alpha values on later clip intersections.

Keep the clip intersection in signed ints until after the empty-range
check, and zero newly sized emitter clip buffers before partial writes.

Testing:
- env LD_LIBRARY_PATH=/home/behdad/harfbuzz/build/src valgrind --leak-check=full --error-exitcode=1 ./build/test/fuzzing/hb-raster-fuzzer test/fuzzing/fonts/clusterfuzz-testcase-minimized-hb-raster-fuzzer-4872362293264384
- meson test -C build raster-fuzzer-chunk-0 --wrap='valgrind --leak-check=full --error-exitcode=1' --print-errorlogs
- meson test -C build

Assisted-by: OpenAI Codex <codex@openai.com>
2026-04-03 17:29:03 -06:00
Behdad EsfahbodandOpenAI Codex 19e4bf2597 [raster] Validate non-rect clip masks before reuse
The raster paint clip code indexed non-rect clip alpha rows directly,
assuming the clip metadata always matched a full stride*height backing
buffer. Fuzzing showed that reused clip objects can reach those reads
with stale scalar state, which turns the row access in
push_clip_rectangle() into a heap-buffer-overflow.

Reset cached clip geometry on acquire, add a validity check for
non-rect alpha masks, and refuse to build new clip intersections from
an invalid mask. The fallback is an empty clip, which keeps the paint
path safe without affecting well-formed clips.

Testing:
- meson test -C build --suite fuzzing --print-errorlogs
- meson test -C build

Co-authored-by: OpenAI Codex <codex@openai.com>
2026-04-03 17:17:49 -06:00
Behdad EsfahbodandOpenAI Codex 9f64e3fde2 [raster] Fail closed on SVG paint stack imbalance
The raster SVG renderer asserted that each element restored the paint
transform, clip, and surface stacks to their entry depths. Fuzzing
found malformed documents that violate that assumption and abort the
process in svg_render_element().

Replace the assertions with explicit stack restoration, discard any
extra group surfaces, and mark the render as failed if the renderer
cannot get back to the saved baseline. The top-level SVG entry point
now checks that failure bit and stops rendering cleanly instead of
crashing.

Testing:
- meson test -C build --suite fuzzing --print-errorlogs
- meson test -C build

Co-authored-by: OpenAI Codex <codex@openai.com>
2026-04-03 17:17:49 -06:00
Behdad EsfahbodandOpenAI Codex 98866c9fef [svg] Zero-initialize doc cache parser structs
MemorySanitizer reported use of uninitialized data while building the
SVG document cache used by vector painting. The parser keeps small
aggregate structs on the stack, and their padding could stay poisoned
as they were copied through the open-element stack.

Zero-initialize the parser stack and the temporary span / element
records before filling their fields. That keeps later copies and
container insertions from carrying undefined padding into the MSan
instrumented path.

Testing:
- meson test -C build --suite fuzzing --print-errorlogs
- meson test -C build

Co-authored-by: OpenAI Codex <codex@openai.com>
2026-04-03 16:49:48 -06:00
Behdad EsfahbodandOpenAI Codex bfafd9d648 [gpu] Check draw encode size arithmetic
The GPU fuzzer can build outline data large enough to stress the size
math inside hb_gpu_draw_encode(). Several totals and byte counts were
computed with unchecked unsigned arithmetic before the existing bounds
checks ran.

Use HarfBuzz's overflow helpers for band-index totals, encoded blob
lengths, byte sizes, and recycled-buffer growth. Also rewrite the
uint16-offset limit check so it does not rely on subtracting from an
already-overflowed total.

Testing:
- meson test -C build --suite fuzzing --print-errorlogs
- meson test -C build

Fixes: https://oss-fuzz.com/testcase-detail/6336503637934080
Co-authored-by: OpenAI Codex <codex@openai.com>
2026-04-03 16:44:50 -06:00
Behdad EsfahbodandOpenAI Codex c111ff82ff [gpu] Fail cleanly on OOM in draw encode
Failing-malloc fuzzing exposed two holes in the GPU draw path.
Accumulation ignored push failures, and encode reused scratch vectors
that could remain poisoned after a previous allocation failure.

Poison the draw object on accumulator OOM, bail out of the remaining
path-building callbacks, and have hb_gpu_draw_encode() return NULL once
the object has failed. Also check the encode scratch resizes and reset
poisoned vectors before reuse. Resetting the draw now fully resets the
curve vector as well, so callers can recover after an OOM by calling
hb_gpu_draw_reset().

Testing:
- meson test -C build --suite fuzzing --print-errorlogs
- meson test -C build

Co-authored-by: OpenAI Codex <codex@openai.com>
2026-04-03 16:29:27 -06:00
Behdad EsfahbodandOpenAI Codex 92b9b1ed82 [docs] Clarify OOM policy for experimental libraries
Document that raster, vector, and gpu still must not crash,
access out of bounds, or corrupt memory under failing-malloc,
but best-effort early failure is acceptable and complex rollback
logic is not required after OOM.

Co-authored-by: OpenAI Codex <codex@openai.com>
2026-04-03 16:24:31 -06:00
Behdad EsfahbodandOpenAI Codex 63c7d00e75 [docs] Require single-issue commits in AGENTS.md
Add an explicit commit-guidance rule to keep each commit focused on a
single issue or concern, instead of combining unrelated fixes,
renames, refactors, or behavior changes.

Co-authored-by: OpenAI Codex <codex@openai.com>
2026-04-03 16:04:14 -06:00
Behdad EsfahbodandOpenAI Codex a4aff49856 [gpu] Fix contour breaks and bounds quantization in encode (#5892)
Encode used adjacent endpoint equality to infer contour breaks, which
fails when two contours touch at the same point. Track contour starts
explicitly during accumulation instead, and use that flag when packing
shared endpoints.

Encode also rounded blob bounds to the nearest quarter unit. That can
shrink the encoded extents and clip coverage at glyph edges. Quantize
mins downward and maxes upward so the blob header always encloses the
actual geometry.

Add focused API tests for both regressions.

Testing:
- meson test -C build

Co-authored-by: OpenAI Codex <codex@openai.com>
2026-04-03 12:09:02 -06:00
Behdad Esfahbod 0234df4db6 [gpu] Fix WebGPU error page not showing when adapter unavailable
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>
2026-04-02 01:26:54 -06:00
Behdad Esfahbod 63cff45ae8 [ci] Disable docs build in Linux CI
Docs are built in the dedicated docs CI workflow.  Remove
gtk-doc-tools and disable docs in the Linux build.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-02 01:22:44 -06:00
Behdad Esfahbod 72bd5d3ae7 [ci] Move doc_tests from Linux CI to docs CI
The doc tests belong with the docs build, not the general
Linux build.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-02 01:22:03 -06:00
Behdad Esfahbod 84f15592dc [gpu] Hoist fwidth out of _hb_gpu_render_single
Compute pixelsPerEm once in hb_gpu_render and pass it down,
so MSAA samples share one fwidth call instead of each
computing their own.  Required for WGSL (fwidth must be
called from uniform control flow) and a minor win for all
backends.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-02 01:20:10 -06:00
Behdad Esfahbod 33baa306b2 [gpu] Fix docs for hb_gpu_draw_set_scale
Use XSince: REPLACEME and add to harfbuzz-sections.txt.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-02 01:19:42 -06:00
Behdad Esfahbod 60629a665d [gpu] Port scale/ppem/MSAA to MSL, WGSL, and HLSL shaders
Port the font-scale header, hb_gpu_ppem(), and adaptive MSAA
from hb_gpu_render() to all shader languages.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-02 01:11:07 -06:00
Behdad Esfahbod b4958570cf [gpu] Trim hb_gpu_render() doc comment
Assisted-by: Claude <noreply@anthropic.com>
2026-04-02 01:01:08 -06:00
Behdad Esfahbod e7c5b839eb [gpu] Store font scale in blob header; auto-MSAA in hb_gpu_render
Add hb_gpu_draw_set_scale() API and store x/y scale in the
glyph blob header (buf[1].b/a).  hb_gpu_draw_glyph() sets it
automatically from the font.

hb_gpu_render() now reads the scale, computes ppem via fwidth,
and automatically blends 4 corner samples at ±1/3 pixel when
ppem < 16 to reduce moiré at small sizes.  Define
HB_GPU_NO_MSAA to disable.

Add hb_gpu_ppem() public shader helper so clients can get
ppem without touching internal functions (e.g. for
hb_gpu_darken).

Remove hb_gpu_render_aaa(), u_upem uniform, and set_upem
plumbing from the demo — no longer needed.

GLSL only for now.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-02 00:59:39 -06:00
Behdad Esfahbod a255d9745b [gpu] Rework MSAA into hb_gpu_render_aaa with caller-provided ppem
Replace the two-program MSAA toggle with hb_gpu_render_aaa()
that takes ppem from the caller and auto-selects single-sample
(ppem >= 16) or 4-corner MSAA (ppem < 16).  This keeps
hb_gpu_render() lean for the fast path while letting the
adaptive function handle small sizes.

The previous approach had the ppem calculation inside the
library shader using 1/fwidth(texcoord), which was wrong by
a factor of upem — MSAA fired at all sizes.  Now the demo
passes correct ppem via a u_upem uniform.

Remove the 'm' key toggle, two-program compilation, and
set_msaa plumbing — no longer needed.

GLSL only for now.

Assisted-by: Claude <noreply@anthropic.com>
2026-04-02 00:40:49 -06:00