From a4e8b5ae8c9151b60750c031c7ba7720a79b0df5 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Mon, 3 Oct 2022 12:31:07 -0700 Subject: [PATCH] calculate font metrics per face --- src/Grid.zig | 11 ++++-- src/font/Face.zig | 85 +++++++++++++++++++++++++++++++++++++++++ src/font/GroupCache.zig | 61 ----------------------------- src/font/main.zig | 10 ----- 4 files changed, 93 insertions(+), 74 deletions(-) diff --git a/src/Grid.zig b/src/Grid.zig index de0eea79d..73fe9092b 100644 --- a/src/Grid.zig +++ b/src/Grid.zig @@ -158,9 +158,14 @@ pub fn init(alloc: Allocator, font_group: *font.GroupCache) !Grid { var shaper = try font.Shaper.init(shape_buf); errdefer shaper.deinit(); - // Load all visible ASCII characters and build our cell width based on - // the widest character that we see. - const metrics = try font_group.metrics(alloc); + // Get our cell metrics based on a regular font ascii 'M'. Why 'M'? + // Doesn't matter, any normal ASCII will do we're just trying to make + // sure we use the regular font. + const metrics = metrics: { + const index = (try font_group.indexForCodepoint(alloc, 'M', .regular, .text)).?; + const face = try font_group.group.faceFromIndex(index); + break :metrics face.metrics; + }; log.debug("cell dimensions={}", .{metrics}); // Create our shader diff --git a/src/font/Face.zig b/src/font/Face.zig index 3068b8cbc..c8ef4df39 100644 --- a/src/font/Face.zig +++ b/src/font/Face.zig @@ -29,6 +29,9 @@ hb_font: harfbuzz.Font, /// a way to declare this. We just assume a font with color is an emoji font. presentation: Presentation, +/// Metrics for this font face. These are useful for renderers. +metrics: Metrics, + /// If a DPI can't be calculated, this DPI is used. This is probably /// wrong on modern devices so it is highly recommended you get the DPI /// using whatever platform method you can. @@ -64,6 +67,7 @@ pub fn initFile(lib: Library, path: [:0]const u8, index: i32, size: DesiredSize) .face = face, .hb_font = hb_font, .presentation = if (face.hasColor()) .emoji else .text, + .metrics = calcMetrics(face), }; } @@ -81,6 +85,7 @@ pub fn init(lib: Library, source: [:0]const u8, size: DesiredSize) !Face { .face = face, .hb_font = hb_font, .presentation = if (face.hasColor()) .emoji else .text, + .metrics = calcMetrics(face), }; } @@ -236,6 +241,86 @@ fn f26dot6ToFloat(v: freetype.c.FT_F26Dot6) f32 { return @intToFloat(f32, v >> 6); } +/// Metrics associated with the font that are useful for renderers to know. +pub const Metrics = struct { + /// Recommended cell width and height for a monospace grid using this font. + cell_width: f32, + cell_height: f32, + + /// For monospace grids, the recommended y-value from the top to set + /// the baseline for font rendering. This is chosen so that things such + /// as the bottom of a "g" or "y" do not drop below the cell. + cell_baseline: f32, +}; + +/// Calculate the metrics associated with a face. This is not public because +/// the metrics are calculated for every face and cached since they're +/// frequently required for renderers and take up next to little memory space +/// in the grand scheme of things. +/// +/// An aside: the proper way to limit memory usage due to faces is to limit +/// the faces with DeferredFaces and reload on demand. A Face can't be converted +/// into a DeferredFace but a Face that comes from a DeferredFace can be +/// deinitialized anytime and reloaded with the deferred face. +fn calcMetrics(face: freetype.Face) Metrics { + const size_metrics = face.handle.*.size.*.metrics; + + // Cell width is calculated by preferring to use 'M' as the width of a + // cell since 'M' is generally the widest ASCII character. If loading 'M' + // fails then we use the max advance of the font face size metrics. + const cell_width: f32 = cell_width: { + if (face.getCharIndex('M')) |glyph_index| { + if (face.loadGlyph(glyph_index, .{ .render = true })) { + break :cell_width f26dot6ToFloat(face.handle.*.glyph.*.advance.x); + } else |_| { + // Ignore the error since we just fall back to max_advance below + } + } + + break :cell_width f26dot6ToFloat(size_metrics.max_advance); + }; + + // Cell height is calculated as the maximum of multiple things in order + // to handle edge cases in fonts: (1) the height as reported in metadata + // by the font designer (2) the maximum glyph height as measured in the + // font and (3) the height from the ascender to an underscore. + const cell_height: f32 = cell_height: { + // The height as reported by the font designer. + const face_height = f26dot6ToFloat(size_metrics.height); + + // The maximum height a glyph can take in the font + const max_glyph_height = f26dot6ToFloat(size_metrics.ascender) - + f26dot6ToFloat(size_metrics.descender); + + // The height of the underscore character + const underscore_height = underscore: { + if (face.getCharIndex('_')) |glyph_index| { + if (face.loadGlyph(glyph_index, .{ .render = true })) { + var res: f32 = f26dot6ToFloat(size_metrics.ascender); + res -= @intToFloat(f32, face.handle.*.glyph.*.bitmap_top); + res += @intToFloat(f32, face.handle.*.glyph.*.bitmap.rows); + break :underscore res; + } else |_| { + // Ignore the error since we just fall back below + } + } + + break :underscore 0; + }; + + break :cell_height @maximum( + face_height, + @maximum(max_glyph_height, underscore_height), + ); + }; + + return .{ + .cell_width = cell_width, + .cell_height = cell_height, + .cell_baseline = cell_height - f26dot6ToFloat(size_metrics.ascender), + }; +} + test { const testFont = @import("test.zig").fontRegular; const alloc = testing.allocator; diff --git a/src/font/GroupCache.zig b/src/font/GroupCache.zig index 86bbbd520..688d018e3 100644 --- a/src/font/GroupCache.zig +++ b/src/font/GroupCache.zig @@ -12,7 +12,6 @@ const Library = @import("main.zig").Library; const Glyph = @import("main.zig").Glyph; const Style = @import("main.zig").Style; const Group = @import("main.zig").Group; -const Metrics = @import("main.zig").Metrics; const Presentation = @import("main.zig").Presentation; const log = std.log.scoped(.font_groupcache); @@ -84,66 +83,6 @@ pub fn reset(self: *GroupCache) void { self.glyphs.clearRetainingCapacity(); } -/// Calculate the metrics for this group. This also warms the cache -/// since this preloads all the ASCII characters. -pub fn metrics(self: *GroupCache, alloc: Allocator) !Metrics { - // Load all visible ASCII characters and build our cell width based on - // the widest character that we see. - const cell_width: f32 = cell_width: { - var cell_width: f32 = 0; - var i: u32 = 32; - while (i <= 126) : (i += 1) { - const index = (try self.indexForCodepoint(alloc, i, .regular, .text)).?; - const face = try self.group.faceFromIndex(index); - const glyph_index = face.glyphIndex(i).?; - const glyph = try self.renderGlyph(alloc, index, glyph_index); - if (glyph.advance_x > cell_width) { - cell_width = @ceil(glyph.advance_x); - } - } - - break :cell_width cell_width; - }; - - // The cell height is the vertical height required to render underscore - // '_' which should live at the bottom of a cell. - const cell_height: f32 = cell_height: { - // Get the '_' char for height - const index = (try self.indexForCodepoint(alloc, '_', .regular, .text)).?; - const face = try self.group.faceFromIndex(index); - const glyph_index = face.glyphIndex('_').?; - const glyph = try self.renderGlyph(alloc, index, glyph_index); - - // This is the height reported by the font face - const face_height: i32 = face.unitsToPxY(face.face.handle.*.height); - - // Determine the height of the underscore char - var res: i32 = face.unitsToPxY(face.face.handle.*.ascender); - res -= glyph.offset_y; - res += @intCast(i32, glyph.height); - - // We take whatever is larger to account for some fonts that - // put the underscore outside f the rectangle. - if (res < face_height) res = face_height; - - break :cell_height @intToFloat(f32, res); - }; - - const cell_baseline = cell_baseline: { - const face = self.group.faces.get(.regular).items[0].face.?; - break :cell_baseline cell_height - @intToFloat( - f32, - face.unitsToPxY(face.face.handle.*.ascender), - ); - }; - - return Metrics{ - .cell_width = cell_width, - .cell_height = cell_height, - .cell_baseline = cell_baseline, - }; -} - /// Get the font index for a given codepoint. This is cached. pub fn indexForCodepoint( self: *GroupCache, diff --git a/src/font/main.zig b/src/font/main.zig index d7463a2e5..201eb0e68 100644 --- a/src/font/main.zig +++ b/src/font/main.zig @@ -49,16 +49,6 @@ pub const Presentation = enum(u1) { emoji = 1, // U+FEOF }; -/// Font metrics useful for things such as grid calculation. -pub const Metrics = struct { - /// The width and height of a monospace cell. - cell_width: f32, - cell_height: f32, - - /// The baseline offset that can be used to place underlines. - cell_baseline: f32, -}; - test { @import("std").testing.refAllDecls(@This()); }