/// Computes one glyph's rendered bounds at : the same
/// per-glyph layout mode and scaled size feed the same bounding-box computation the
@@ -619,68 +646,51 @@ private static GlyphMetrics CreateGlyphMetrics(ushort glyphId, GlyphOptions opti
/// The glyph options, including the font, origin, and layout mode.
/// The rendered glyph bounds.
private static FontRectangle GetGlyphBounds(FontGlyphMetrics metrics, GlyphOptions options)
- => metrics.GetBoundingBox(
- options.GetGlyphLayoutMode(metrics.CodePoint),
- options.Origin,
+ {
+ GlyphLayoutMode layoutMode = options.GetGlyphLayoutMode(metrics.CodePoint);
+ return metrics.GetBoundingBox(
+ layoutMode,
+ GetAnchoredOrigin(options, layoutMode),
metrics.GetScaledSize(options.Font.Size, options.Dpi));
+ }
///
- /// Computes one glyph's logical advance rectangle at ,
- /// mirroring the line-box construction the layout engine applies to a single glyph: the
- /// line height is the em box, and the ascender is balanced by the delta that centers the
- /// em box within the font's declared line height. Vertical layouts center the cell on the
- /// origin and extend downward by the advance the layout direction consumes.
+ /// Computes one glyph's logical advance: a zero-based measure of the space the glyph
+ /// consumes, matching the text-level advance contract. The origin and baseline anchoring
+ /// never move it; positioned geometry is reported by the bounds overloads.
///
/// The glyph metrics.
- /// The glyph options, including the font, origin, and layout mode.
- /// The logical advance rectangle.
+ /// The glyph options, including the font and layout mode.
+ /// The zero-based logical advance rectangle.
private static FontRectangle GetGlyphAdvance(FontGlyphMetrics metrics, GlyphOptions options)
{
float scaledSize = metrics.GetScaledSize(options.Font.Size, options.Dpi);
Vector2 scale = new(scaledSize / metrics.ScaleFactor.X, scaledSize / metrics.ScaleFactor.Y);
- Vector2 origin = options.Origin;
-
- // Match the layout engine's CSS-style line box: the em box is the line height, and
- // the delta centers it within the font's declared line height.
- // Reference: TextLayout.LineBreaking line-height calculation.
float emHeight = metrics.UnitsPerEm * scale.Y;
switch (options.GetGlyphLayoutMode(metrics.CodePoint))
{
case GlyphLayoutMode.Vertical:
- {
- float advanceWidth = metrics.AdvanceWidth * scale.X;
- return new FontRectangle(
- origin.X - (advanceWidth * .5F),
- origin.Y,
- advanceWidth,
- metrics.AdvanceHeight * scale.Y);
- }
-
+ return new FontRectangle(0, 0, metrics.AdvanceWidth * scale.X, metrics.AdvanceHeight * scale.Y);
case GlyphLayoutMode.VerticalRotated:
- {
// A rotated glyph advances along the column by its horizontal advance and its
// line box lies across the column.
- return new FontRectangle(
- origin.X - (emHeight * .5F),
- origin.Y,
- emHeight,
- metrics.AdvanceWidth * scale.X);
- }
-
+ return new FontRectangle(0, 0, emHeight, metrics.AdvanceWidth * scale.X);
default:
- {
- // The origin is the baseline pen position; the delta-adjusted ascender places
- // the cell top exactly where layout places the line-box top above the baseline.
- HorizontalMetrics horizontalMetrics = options.Font.FontMetrics.HorizontalMetrics;
- float delta = ((horizontalMetrics.LineHeight * scale.Y) - emHeight) * .5F;
- float ascender = (horizontalMetrics.Ascender * scale.Y) - delta;
- return new FontRectangle(
- origin.X,
- origin.Y - ascender,
- metrics.AdvanceWidth * scale.X,
- emHeight);
- }
+ return new FontRectangle(0, 0, metrics.AdvanceWidth * scale.X, emHeight);
}
}
+
+ ///
+ /// Places a glyph's zero-based advance at , mirroring the
+ /// absolute-advance composition the text-level renderable bounds use.
+ ///
+ /// The glyph metrics.
+ /// The glyph options, including the font, origin, and layout mode.
+ /// The advance rectangle placed at the origin.
+ private static FontRectangle GetAbsoluteAdvance(FontGlyphMetrics metrics, GlyphOptions options)
+ {
+ FontRectangle advance = GetGlyphAdvance(metrics, options);
+ return new FontRectangle(options.Origin.X, options.Origin.Y, advance.Width, advance.Height);
+ }
}
diff --git a/src/SixLabors.Fonts/TextOptions.cs b/src/SixLabors.Fonts/TextOptions.cs
index 35d5465ff..fffd4d8a3 100644
--- a/src/SixLabors.Fonts/TextOptions.cs
+++ b/src/SixLabors.Fonts/TextOptions.cs
@@ -38,6 +38,9 @@ public TextOptions(TextOptions options)
this.LineSpacing = options.LineSpacing;
this.Origin = options.Origin;
this.WrappingLength = options.WrappingLength;
+ this.VisibleBounds = options.VisibleBounds;
+ this.TextBaseline = options.TextBaseline;
+ this.BaselineOffset = options.BaselineOffset;
this.MaxLines = options.MaxLines;
this.WordBreaking = options.WordBreaking;
this.TextEllipsis = options.TextEllipsis;
@@ -147,6 +150,42 @@ public float LineSpacing
///
public float WrappingLength { get; set; } = -1F;
+ ///
+ /// Gets or sets the visible region in pixel units (px) used when rendering text.
+ /// Whole lines that fall outside the region are skipped and the remaining lines are
+ /// positioned as if all lines had been rendered.
+ ///
+ ///
+ /// If value is then culling is disabled.
+ ///
+ public FontRectangle? VisibleBounds { get; set; }
+
+ ///
+ /// Gets or sets which reference line of the first laid-out line is placed at
+ /// along the block flow axis.
+ ///
+ ///
+ /// Baseline positions derive from the metrics of : horizontal layouts
+ /// anchor along Y from the alphabetic baseline, vertical layouts along X from the central
+ /// column axis. When the value is not the block
+ /// alignment along the flow axis does not apply; additional wrapped lines stack relative
+ /// to the anchored first line.
+ ///
+ public TextBaseline TextBaseline { get; set; }
+
+ ///
+ /// Gets or sets an additional shift of the text away from its anchored position, in pixel
+ /// units along the block flow axis. Positive values shift toward the text's over side:
+ /// upward for horizontal layouts, toward the over column side for vertical layouts, and
+ /// away from the line along its normal when the text follows a path.
+ ///
+ ///
+ /// The shift composes with and moves rendered glyphs, ink
+ /// bounds, and decorations as a unit. The logical advance is unaffected, matching the
+ /// CSS and SVG baseline-shift model.
+ ///
+ public float BaselineOffset { get; set; }
+
///
/// Gets or sets the maximum number of lines to lay out.
///
diff --git a/tests/Browser/TextBaseline.html b/tests/Browser/TextBaseline.html
new file mode 100644
index 000000000..3b7e60a3d
--- /dev/null
+++ b/tests/Browser/TextBaseline.html
@@ -0,0 +1,379 @@
+
+
+
+
+
+ Text baseline browser comparison
+
+
+
+
+ Browser text baseline comparison
+
+
+
+ Open Sans horizontal, baseline anchored at the red rule, 72pt
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Open Sans vertical upright, baseline anchored at the red rule, 72pt
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Open Sans vertical mixed, baseline anchored at the red rule, 72pt
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Noto Sans SC subset horizontal, baseline anchored at the red rule, 72pt
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Noto Sans SC subset vertical upright, baseline anchored at the red rule, 72pt
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Noto Sans SC subset vertical mixed, baseline anchored at the red rule, 72pt
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Browser text baseline shift comparison
+
+ The browser column applies SVG baseline-shift on a tspan, the browser surface for the
+ CSS baseline-shift model; vertical-align with a length is the equivalent in flow
+ layout. The library column renders the same text with TextOptions.BaselineOffset in
+ pixel units. Positive shifts move toward the over side and the logical advance is
+ unchanged in both columns.
+
+
+
+
+ Open Sans horizontal, alphabetic baseline at the red rule, 72pt
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Open Sans horizontal, hanging baseline at the red rule, 72pt
+
+ The shift composes with the selected anchor: at zero shift the hanging baseline sits
+ on the rule and every shifted row moves from that anchored position.
+
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Open Sans vertical upright, central baseline at the red rule, 72pt
+
+ In vertical flows the over side is physically right for both vertical-rl and
+ vertical-lr, so positive shifts move the columns right, matching the library's +X.
+
+
+
+
Browser
+
SixLabors.Fonts actual output
+
Open Sans vertical mixed, central baseline at the red rule, 72pt
+
+
+
Browser
+
SixLabors.Fonts actual output
+