Migrating from fogleman/gg to gogpu/gg

[rcarlier]

Hello

I've done the "great replacement", migrating from fogleman to gogpu/gg for my programming language Richnou.

Overall, it's going pretty well !!!

A little rewriting around font :

• rt.Context.SetFontFace(face) undefined
• dc.LoadFontFace(p, size) deprecated
• text positionning - which may not have the same default values (I need to investigate)

And the management of background colors on the Context (I primarily work in hexadecimal.)

• rt.Context.ClearWithColor(gg.Hex(bg))

A "sort of bug" (It's the fault of log and log2) when we passed a NaN value to draw a point...

-600 -179.51958020513098
-600 165.04614733788785
-600 179.519580205131
-600 NaN
runtime: goroutine stack exceeds 1000000000-byte limit
runtime: sp=0x3178e2c6360 stack=[0x3178e2c6000, 0x317ae2c6000]
fatal error: stack overflow

Full log here : https://github.com/rcarlier/tests-gogpugg/blob/main/20260520/log.log

Unit Test:

And apart from that... well, nothing 😃

[rcarlier]

Some other bug/problem/annoyance

1. Color are not always the same, i think it's when it in Hexa with alpha (#RRGGBBAA)
2. Idem
3. Polygon are not drawn from the same angle

Edited..

- problem with alpha in hexa
+ It's my fault, I changed the internal alpha processing (from 0-255 to 0-1)
+ gogpu/gg is correct. Sorry.

[kolkov]

Hi @rcarlier! Great to see the migration going well! Here's a guide for each point:

1. SetFontFace → SetFont

gogpu/gg redesigned the text API around text.FontSource (heavyweight, thread-safe font parser) + text.Face (lightweight, size-specific view):

// fogleman/gg:
face := truetype.NewFace(f, &truetype.Options{Size: 24})
dc.SetFontFace(face)

// gogpu/gg:
source, err := text.NewFontSourceFromFile("font.ttf")
face := source.Face(24.0)
dc.SetFont(face)

// Multiple sizes from same source (no re-parsing):
faceSmall := source.Face(12.0)
faceLarge := source.Face(48.0)

2. LoadFontFace deprecated

Still works, but the two-step pattern above is preferred — it separates font parsing (once) from face creation (cheap, multiple sizes).

3. Text positioning

DrawString(s, x, y) is baseline-compatible with fogleman/gg — y is the baseline in both.

DrawStringAnchored has different anchor semantics:

• fogleman/gg: anchor shifts from baseline position
• gogpu/gg: anchor is position within bounding box — (0,0) = top-left, (0.5, 0.5) = center, (1,1) = bottom-right

If you use only DrawString, no changes needed.

4. NaN stack overflow — confirmed bug 🐛

You found a real bug! When NaN coordinates reach flattenCubicRec in our stroke expander, the flatness check dist < tolerance is always false (IEEE 754: NaN comparisons return false) → infinite recursion → stack overflow.

Our edge builder already has a depth > 10 guard for this, but the stroke expander doesn't. We'll fix this — thank you for the report!

5. ClearWithColor(gg.Hex(bg))

This works correctly — Hex() returns gg.RGBA which ClearWithColor accepts directly. No issues here.

---

Thanks for the detailed migration report — and for catching the NaN bug! We'll track it as a separate issue.

[rcarlier]

Hi!

For the bug... i'm a BugTracker (as I'm a programming teacher, that must be where it comes from).

I investigated text/font, and indeed we are moving towards the best! Differentiating font loading from size adjustment is great (I need to integrate it into my language now).

For text positionning, it's all good.

Some experiments:

By the way, I don't know if it's planned (nor if it's a lot of work), but here are some suggestions:

• It would be useful to be able to specify a background and outline color for the text.
• As far as I can see, the (super) pixelperfect mode doesn't affect the text?

[kolkov]

@rcarlier Great to see the experiments! Your rendering output looks fantastic.

On your suggestions:

Text background + outline color:

Text stroke/outline is a first-class feature in all enterprise 2D engines (Skia, Cairo, HTML5 Canvas). We're adding it — tracked as ADR-033:

// Outlined text (coming soon):
dc.SetLineWidth(3.0)
dc.SetHexColor("#000000")
dc.StrokeString("Hello", x, y)   // stroke outlines
dc.SetHexColor("#FFFFFF")
dc.DrawString("Hello", x, y)     // fill on top

For text background, you can already do this today:

w, _ := dc.MeasureString("Hello")
m := dc.Font().Metrics()
h := m.Ascent + m.Descent
dc.Push()
dc.SetHexColor("#333333")
dc.DrawRectangle(x-pad, y-m.Ascent-pad, w+2*pad, h+2*pad)
dc.Fill()
dc.Pop()
dc.DrawString("Hello", x, y)

Pixel-perfect text:

Correct observation — SetAntiAlias(false) is intentionally geometry-only. This matches Skia (SkPaint::setAntiAlias ≠ SkFont::Edging) and Cairo (separate cairo_font_options_set_antialias). Text AA is a different problem with different solutions.

We're planning TextModeAliased — binary 1-bit glyph masks, no gray pixels (tracked as ADR-034):

dc.SetTextMode(gg.TextModeAliased)  // pixel-perfect text
dc.DrawString("Hello", x, y)

Polygon rotation:

You're right — our DrawRegularPolygon starts with vertex at 3 o'clock (pure math), while fogleman/gg starts at 12 o'clock with even-side flat-top correction. We'll fix this for compatibility — it's a 3-line change.

NaN bug (#341):

Tracked and will be fixed — missing recursion depth limit in stroke curve flattening.