getOrCreate(@Nullable Font font) {
Font resolved = resolveFont(font);
String key = resolved.getFontName(Locale.ENGLISH) + "." + resolved.getStyle() + "." + resolved.getSize();
- return CACHE.computeIfAbsent(key, _ -> CompletableFuture.supplyAsync(() -> new SdfGlyphAtlas(key, resolved)));
+ return CACHE.computeIfAbsent(key, _ -> {
+ log.debug("Starting SDF atlas build for key={}", key);
+ return CompletableFuture.supplyAsync(() -> new SdfGlyphAtlas(key, resolved), GLYPH_EXECUTOR);
+ });
}
/**
* Return the atlas if fully built, or {@code null} if still constructing.
+ *
+ * If the previous build failed (future completed exceptionally), the
+ * failed future is removed and a fresh build is started so that a
+ * transient error does not permanently disable the atlas.
*/
public static @Nullable SdfGlyphAtlas getIfReady(@Nullable Font font) {
Font resolved = resolveFont(font);
@@ -92,11 +123,18 @@ public static CompletableFuture getOrCreate(@Nullable Font font)
CompletableFuture f = CACHE.get(key);
if (f != null && f.isDone()) {
try {
- return f.get();
- } catch (Exception ignored) {
+ SdfGlyphAtlas atlas = f.get();
+ return atlas;
+ } catch (Exception e) {
+ log.error("SDF atlas build failed for key={}, retrying", key, e);
+ CACHE.remove(key, f);
+ f = null;
}
}
- if (f == null) getOrCreate(font);
+ if (f == null) {
+ log.info("No atlas future for key={}, starting build", key);
+ getOrCreate(font);
+ }
return null;
}
@@ -115,7 +153,7 @@ public Font font() {
}
public int awtHeight() {
- return this.font.getSize();
+ return this.awtHeight;
}
public int awtAscent() {
@@ -131,12 +169,40 @@ public SdfGlyphPage page(int index) {
}
/**
- * Get (or lazily create) the glyph entry for a codepoint.
+ * Get the glyph entry for a codepoint. If the glyph is not yet in the
+ * atlas, requests async creation and returns {@code null}. The caller
+ * should handle the missing glyph gracefully (e.g. advance by a default
+ * width); the glyph will be available on the next call.
*/
public @Nullable GlyphEntry glyph(int codepoint, Consumer pageConsumer) {
GlyphEntry entry = this.glyphMap.get(codepoint);
if (entry != null) return entry;
- return createGlyph(codepoint, pageConsumer);
+ // Trigger async creation on background thread
+ if (this.pendingGlyphs.add(codepoint)) {
+ GLYPH_EXECUTOR.submit(() -> createGlyphAsync(codepoint));
+ }
+ return null;
+ }
+
+ /**
+ * Background-thread entry point for glyph creation.
+ * Synchronized to ensure only one glyph is created at a time per atlas,
+ * avoiding races on page state (nextCol, nextRow, image pixels).
+ */
+ private void createGlyphAsync(int codepoint) {
+ try {
+ synchronized (this) {
+ // Double-check: may have been created since we were enqueued
+ if (this.glyphMap.containsKey(codepoint)) return;
+ createGlyph(codepoint, SdfGlyphPage::updateHash);
+ }
+ // Invalidate cached layouts so they pick up the new glyph
+ SdfTextLayout.invalidateAtlas(this.key);
+ } catch (Exception e) {
+ log.error("Failed to create SDF glyph for codepoint {} (U+{})", codepoint, Integer.toHexString(codepoint).toUpperCase(), e);
+ } finally {
+ this.pendingGlyphs.remove(codepoint);
+ }
}
public int measureText(String text) {
@@ -169,9 +235,8 @@ public int measureCodepoint(int codepoint) {
// ââ Glyph creation ââââââââââââââââââââââââââââââââââââââââââ
- private @Nullable GlyphEntry createGlyph(int codepoint, Consumer pageConsumer) {
+ private GlyphEntry createGlyph(int codepoint, Consumer pageConsumer) {
BufferedImage mask = renderMask(codepoint);
- if (mask == null) return null;
int pageIdx = findOrCreatePageIndex();
SdfGlyphPage page = this.pages.get(pageIdx);
@@ -221,7 +286,7 @@ private BufferedImage renderMask(int codepoint) {
g.setColor(new Color(0, 0, 0, 0));
g.fillRect(0, 0, this.cellSize, this.cellSize);
g.setColor(Color.WHITE);
- g.drawString(s, 2, Math.min(this.cellSize - 4, this.awtAscent + 2));
+ g.drawString(s, 2, this.awtAscent + 2);
} finally {
g.dispose();
}
diff --git a/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfGlyphPage.java b/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfGlyphPage.java
index 955143fe..03fbc16b 100644
--- a/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfGlyphPage.java
+++ b/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfGlyphPage.java
@@ -1,20 +1,23 @@
package dev.anvilcraft.lib.v2.font.sdf;
import net.minecraft.resources.Identifier;
+import org.jetbrains.annotations.ApiStatus;
import java.awt.image.BufferedImage;
+import java.util.concurrent.atomic.AtomicInteger;
/**
* A single 1024Ã1024 atlas page holding packed glyphs.
*/
+@ApiStatus.Internal
public final class SdfGlyphPage {
private static final int SIZE = SdfGlyphAtlas.PAGE_SIZE;
final BufferedImage image;
- int hash = 1;
+ final AtomicInteger version = new AtomicInteger();
final int cols, rows;
int nextCol, nextRow;
Identifier textureId;
- boolean dirty = true;
+ volatile boolean dirty = true;
SdfGlyphPage(int paddedCellSize) {
this.cols = SIZE / paddedCellSize;
@@ -26,7 +29,7 @@ boolean hasSpace() {
return nextRow < rows;
}
- SdfGlyphAtlas.GlyphEntry placeGlyph(SdfGlyphAtlas atlas, BufferedImage mask) {
+ synchronized SdfGlyphAtlas.GlyphEntry placeGlyph(SdfGlyphAtlas atlas, BufferedImage mask) {
int col = nextCol, row = nextRow;
int padX = col * atlas.paddedCellSize;
int padY = row * atlas.paddedCellSize;
@@ -42,7 +45,7 @@ SdfGlyphAtlas.GlyphEntry placeGlyph(SdfGlyphAtlas atlas, BufferedImage mask) {
return new SdfGlyphAtlas.GlyphEntry(0, innerX, innerY, atlas.cellSize, atlas.cellSize, 0);
}
- void fillPaddingForCell(SdfGlyphAtlas atlas, SdfGlyphAtlas.GlyphEntry e) {
+ synchronized void fillPaddingForCell(SdfGlyphAtlas atlas, SdfGlyphAtlas.GlyphEntry e) {
int col = (e.atlasX() - atlas.padding) / atlas.paddedCellSize;
int row = (e.atlasY() - atlas.padding) / atlas.paddedCellSize;
SdfGlyphAtlas.fillPadding(
@@ -56,6 +59,6 @@ void fillPaddingForCell(SdfGlyphAtlas atlas, SdfGlyphAtlas.GlyphEntry e) {
}
public void updateHash() {
- this.hash = SdfAtlasTexture.hashImage(this.image);
+ this.version.incrementAndGet();
}
}
diff --git a/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfTextLayout.java b/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfTextLayout.java
index 434825ad..8c7b207c 100644
--- a/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfTextLayout.java
+++ b/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfTextLayout.java
@@ -1,18 +1,29 @@
package dev.anvilcraft.lib.v2.font.sdf;
import net.minecraft.resources.Identifier;
+import org.jetbrains.annotations.ApiStatus;
import org.jspecify.annotations.Nullable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
/**
* CPU-side glyph layout output for SDF text rendering, grouped by atlas page.
+ *
+ * Layouts are cached by {@code (atlasKey, text, scale)} to avoid redundant
+ * computation each frame. Quads are stored with positions relative to the
+ * layout origin; the renderer supplies the screen-space offset.
*/
+@ApiStatus.Internal
public final class SdfTextLayout {
+ private static final int MAX_CACHE_SIZE = 1024;
+ private static final Map LAYOUT_CACHE = new ConcurrentHashMap<>();
+
private final List pages;
private final int width;
private final int height;
@@ -23,12 +34,60 @@ private SdfTextLayout(List pages, int width, int height) {
this.height = height;
}
+ /**
+ * Compute glyph layout for a string. The returned quads have positions
+ * relative to (0, 0); add {@code x}/{@code y} when rendering.
+ *
+ * Result is cached when all glyphs are available in the atlas.
+ */
public static SdfTextLayout fromAtlas(SdfGlyphAtlas atlas, @Nullable String text, int x, int y, float scale) {
if (text == null || text.isEmpty())
- return new SdfTextLayout(List.of(), 0, 0);
+ return EMPTY;
+
+ int scaleInt = Math.round(scale * 1000f);
+ CacheKey key = new CacheKey(atlas.key(), text, scaleInt);
+ SdfTextLayout cached = LAYOUT_CACHE.get(key);
+ if (cached != null) return cached;
+
+ SdfTextLayout layout = computeLayout(atlas, text, scale, scaleInt);
+ if (layout != null && layout.allGlyphsAvailable) {
+ evictIfNeeded();
+ LAYOUT_CACHE.put(key, layout);
+ }
+ return layout;
+ }
+
+ /**
+ * Invalidate cached layouts for a specific atlas (e.g. after glyph additions).
+ */
+ public static void invalidateAtlas(String atlasKey) {
+ LAYOUT_CACHE.keySet().removeIf(k -> k.atlasKey.equals(atlasKey));
+ }
+
+ /**
+ * Clear all cached layouts.
+ */
+ public static void clearCache() {
+ LAYOUT_CACHE.clear();
+ }
+
+ private static void evictIfNeeded() {
+ if (LAYOUT_CACHE.size() >= MAX_CACHE_SIZE) {
+ // Evict half the entries (simple random-ish eviction via iterator)
+ var it = LAYOUT_CACHE.keySet().iterator();
+ int toRemove = MAX_CACHE_SIZE / 2;
+ for (int i = 0; i < toRemove && it.hasNext(); i++) {
+ it.next();
+ it.remove();
+ }
+ }
+ }
- int penX = x, maxHeight = 0, totalWidth = 0;
+ @Nullable
+ private static SdfTextLayout computeLayout(SdfGlyphAtlas atlas, String text, float scale, int scaleInt) {
+ int penX = 0, maxHeight = 0;
java.util.Map> buckets = new java.util.LinkedHashMap<>();
+ boolean allAvailable = true;
Set glyphPages = new HashSet<>();
for (int ci = 0; ci < text.length(); ) {
@@ -37,6 +96,7 @@ public static SdfTextLayout fromAtlas(SdfGlyphAtlas atlas, @Nullable String text
SdfGlyphAtlas.GlyphEntry glyph = atlas.glyph(cp, glyphPages::add);
if (glyph == null) {
+ allAvailable = false;
penX += Math.round(Math.max(6, atlas.font().getSize() / 2) * scale);
continue;
}
@@ -53,7 +113,8 @@ public static SdfTextLayout fromAtlas(SdfGlyphAtlas atlas, @Nullable String text
int w = Math.round(glyph.width() * scale);
int h = Math.round(glyph.height() * scale);
- GlyphQuad quad = new GlyphQuad(penX, y, penX + w, y + h, u0, v0, u1, v1, (char) cp);
+ // Positions relative to layout origin (0, 0)
+ GlyphQuad quad = new GlyphQuad(penX, 0, penX + w, h, u0, v0, u1, v1, (char) cp);
buckets.computeIfAbsent(glyph.pageIndex(), _ -> new ArrayList<>()).add(quad);
penX += Math.max(1, Math.round(glyph.advance() * scale));
@@ -69,14 +130,21 @@ public static SdfTextLayout fromAtlas(SdfGlyphAtlas atlas, @Nullable String text
pages.add(new PageQuads(pi, tex, page.image.getWidth(), page.image.getHeight(), entry.getValue()));
}
- totalWidth = Math.max(0, penX - x);
- return new SdfTextLayout(pages, totalWidth, maxHeight);
+ SdfTextLayout layout = new SdfTextLayout(pages, penX, maxHeight);
+ layout.allGlyphsAvailable = allAvailable;
+ return layout;
}
+ private boolean allGlyphsAvailable = true;
+
+ private static final SdfTextLayout EMPTY = new SdfTextLayout(List.of(), 0, 0);
+
public List pages() { return Collections.unmodifiableList(this.pages); }
public int width() { return this.width; }
public int height() { return this.height; }
+ private record CacheKey(String atlasKey, String text, int scaleInt) {}
+
public record PageQuads(int pageIndex, @Nullable Identifier atlasTexture,
int pageWidth, int pageHeight, List quads) {}
diff --git a/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfTextRenderer.java b/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfTextRenderer.java
index 42bffae2..187e0d38 100644
--- a/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfTextRenderer.java
+++ b/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/SdfTextRenderer.java
@@ -1,5 +1,6 @@
package dev.anvilcraft.lib.v2.font.sdf;
+import com.google.common.annotations.Beta;
import com.mojang.blaze3d.systems.RenderSystem;
import com.mojang.blaze3d.textures.FilterMode;
import com.mojang.blaze3d.textures.GpuSampler;
@@ -10,13 +11,12 @@
import net.minecraft.network.chat.FormattedText;
import net.minecraft.network.chat.Style;
import net.minecraft.util.FormattedCharSequence;
+import org.joml.Matrix3x2f;
+import org.joml.Matrix3x2fStack;
import org.jspecify.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import java.awt.Font;
import java.util.List;
-import org.joml.Matrix3x2f;
/**
* SDF text renderer that draws strings via the SDF text render pipeline.
@@ -24,14 +24,22 @@
* Uses a CPU-generated SDF glyph atlas uploaded to a GPU texture,
* sampled by a custom fragment shader for smooth anti-aliased text.
*/
+@Beta
public final class SdfTextRenderer {
- private static final Logger LOGGER = LoggerFactory.getLogger(SdfTextRenderer.class);
-
private final GpuSampler diffuseSampler = RenderSystem.getSamplerCache().getClampToEdge(FilterMode.LINEAR);
public SdfTextRenderer() {
}
+ /**
+ * Get the SDF atlas for a font, blocking until it is ready on first access.
+ * The atlas is cached forever, so only the very first call for a particular
+ * font blocks (typically ~200-400 ms while the glyph atlas is built).
+ */
+ private static SdfGlyphAtlas getAtlas(@Nullable Font font) {
+ return SdfGlyphAtlas.getOrCreate(font).join();
+ }
+
public void drawString(
GuiGraphicsExtractor graphics,
@Nullable Font font,
@@ -42,20 +50,19 @@ public void drawString(
boolean dropShadow
) {
if (text == null || text.isEmpty()) return;
- SdfGlyphAtlas atlas = SdfGlyphAtlas.getIfReady(font);
- if (atlas == null) return;
- drawStringWithAtlas(graphics, atlas, text, x, y, color);
+ drawStringWithAtlas(graphics, getAtlas(font), text, x, y, color);
}
- private void drawStringWithAtlas(GuiGraphicsExtractor graphics, SdfGlyphAtlas atlas,
- String text, int x, int y, int color) {
+ private void drawStringWithAtlas(
+ GuiGraphicsExtractor graphics, SdfGlyphAtlas atlas,
+ String text, int x, int y, int color
+ ) {
float scale = scaleFor(atlas);
- int quadY = y - 2;
- SdfTextLayout layout = SdfTextLayout.fromAtlas(atlas, text, x, quadY, scale);
- if (layout.pages().isEmpty()) return;
SdfAtlasTexture.ensureUploaded(atlas);
+ SdfTextLayout layout = SdfTextLayout.fromAtlas(atlas, text, x, y, scale);
+ if (layout.pages().isEmpty()) return;
for (SdfTextLayout.PageQuads pq : layout.pages()) {
- drawAtlasPipeline(graphics, pq, this.diffuseSampler, color);
+ drawAtlasPipeline(graphics, pq, this.diffuseSampler, color, x, y);
}
}
@@ -103,7 +110,10 @@ public void drawFormatted(
int color,
boolean dropShadow
) {
- int[] pen = {x, x};
+ int[] pen = {
+ x,
+ x
+ };
StringBuilder buf = new StringBuilder();
int[] segColor = {color};
boolean[] segBold = {false};
@@ -145,15 +155,13 @@ public void drawFormatted(
}
private int flushFormattedSegment(GuiGraphicsExtractor graphics, @Nullable Font font, String text, int x, int y, int color) {
- SdfGlyphAtlas atlas = SdfGlyphAtlas.getIfReady(font);
- if (atlas == null) return x;
+ SdfGlyphAtlas atlas = getAtlas(font);
float scale = scaleFor(atlas);
- int quadY = y - 2;
- SdfTextLayout layout = SdfTextLayout.fromAtlas(atlas, text, x, quadY, scale);
SdfAtlasTexture.ensureUploaded(atlas);
+ SdfTextLayout layout = SdfTextLayout.fromAtlas(atlas, text, x, y, scale);
for (SdfTextLayout.PageQuads pq : layout.pages()) {
if (pq.atlasTexture() != null && !pq.quads().isEmpty()) {
- drawAtlasPipeline(graphics, pq, this.diffuseSampler, color);
+ drawAtlasPipeline(graphics, pq, this.diffuseSampler, color, x, y);
}
}
return x + layout.width();
@@ -173,14 +181,18 @@ private static void drawDecorations(
) {
if (x1 <= x0) return;
int lh = Minecraft.getInstance().font.lineHeight;
+ Matrix3x2fStack pose = graphics.pose();
+ pose.pushMatrix();
+ pose.scale(1.0f, 0.5f);
if (strikethrough) {
- int sy = y + lh / 2;
+ int sy = (y + lh / 2) * 2;
graphics.fill(x0, sy, x1, sy + 1, color);
}
if (underline) {
- int sy = y + lh;
+ int sy = (y + lh - 2) * 2;
graphics.fill(x0, sy, x1, sy + 1, color);
}
+ pose.popMatrix();
}
public void drawWrapped(
@@ -193,8 +205,7 @@ public void drawWrapped(
int color,
boolean dropShadow
) {
- SdfGlyphAtlas atlas = SdfGlyphAtlas.getIfReady(font);
- if (atlas == null) return;
+ SdfGlyphAtlas atlas = getAtlas(font);
float scale = scaleFor(atlas);
List lines = wrapLines(atlas, text.getString(), width, scale);
int lineHeight = Minecraft.getInstance().font.lineHeight;
@@ -209,8 +220,7 @@ public void drawCentered(GuiGraphicsExtractor graphics, @Nullable Font font, Com
public void drawCentered(GuiGraphicsExtractor graphics, @Nullable Font font, FormattedCharSequence text, int x, int y, int color) {
String value = flattenToString(text);
- SdfGlyphAtlas atlas = SdfGlyphAtlas.getIfReady(font);
- if (atlas == null) return;
+ SdfGlyphAtlas atlas = getAtlas(font);
float scale = scaleFor(atlas);
int drawX = x - Math.round(atlas.measureText(value) * scale) / 2;
this.drawFormatted(graphics, font, text, drawX, y, color, false);
@@ -237,7 +247,9 @@ private static void drawAtlasPipeline(
GuiGraphicsExtractor graphics,
SdfTextLayout.PageQuads pq,
GpuSampler diffuseSampler,
- int color
+ int color,
+ int originX,
+ int originY
) {
if (pq.atlasTexture() == null || pq.quads().isEmpty()) return;
SdfTextRenderState state = new SdfTextRenderState(
@@ -248,6 +260,8 @@ private static void drawAtlasPipeline(
pq.pageWidth(),
pq.pageHeight(),
color,
+ originX,
+ originY,
graphics.peekScissorStack()
);
graphics.submitGuiElementRenderState(state);
diff --git a/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/state/SdfTextRenderState.java b/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/state/SdfTextRenderState.java
index 64e1141f..a13b702e 100644
--- a/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/state/SdfTextRenderState.java
+++ b/module.font/src/main/java/dev/anvilcraft/lib/v2/font/sdf/state/SdfTextRenderState.java
@@ -12,18 +12,18 @@
import net.minecraft.client.gui.render.TextureSetup;
import net.minecraft.client.renderer.texture.AbstractTexture;
import net.minecraft.resources.Identifier;
+import org.jetbrains.annotations.ApiStatus;
import org.joml.Matrix3x2f;
import org.jspecify.annotations.Nullable;
import java.util.List;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Render state for SDF text rendering.
*
* Coordinates are in screen space and will be transformed via the pose matrix.
*/
+@ApiStatus.Internal
public record SdfTextRenderState(
Matrix3x2f pose,
List glyphs,
@@ -32,10 +32,10 @@ public record SdfTextRenderState(
int atlasWidth,
int atlasHeight,
int color,
+ int originX,
+ int originY,
@Nullable ScreenRectangle scissorArea
) implements LibGuiElementRenderState {
- private static final Logger LOGGER = LoggerFactory.getLogger(SdfTextRenderState.class);
-
@Override
public RenderPipeline pipeline() {
return ALFPipelines.SDF_TEXT;
@@ -55,14 +55,16 @@ public void executeDrawAfterSetPipeline(RenderPass renderPass) {
@Override
public void buildVertices(VertexConsumer consumer) {
+ int ox = this.originX;
+ int oy = this.originY;
for (SdfTextLayout.GlyphQuad quad : this.glyphs) {
// Build quad vertices in screen space
// The pose matrix will handle transformation to clip space
- float x0 = quad.x0();
- float y0 = quad.y0();
- float x1 = quad.x1();
- float y1 = quad.y1();
+ float x0 = quad.x0() + ox;
+ float y0 = quad.y0() + oy;
+ float x1 = quad.x1() + ox;
+ float y1 = quad.y1() + oy;
float u0 = quad.u0();
float v0 = quad.v0();
diff --git a/roseau.yaml b/roseau.yaml
new file mode 100644
index 00000000..1f196728
--- /dev/null
+++ b/roseau.yaml
@@ -0,0 +1,9 @@
+common:
+ excludes:
+ annotations:
+ - name: java.lang.Deprecated
+ - name: com.google.common.annotations.Beta
+ - name: org.jetbrains.annotations.ApiStatus$Experimental
+ - name: org.jetbrains.annotations.ApiStatus$Internal
+ - name: org.jetbrains.annotations.ApiStatus$Obsolete
+ - name: org.jetbrains.annotations.ApiStatus$ScheduledForRemoval