tiny.ui.asset

1pub const Capacity = struct {2    total_bytes: usize,3    font_bytes: usize,4    image_bytes: usize,5    string_bytes: usize,6    owned_bytes: usize,78    pub fn derive(limits: Limits) Error!Capacity {9        if (limits.fonts > std.math.maxInt(u32) / family_bytes_per_font) return error.CapacityOverflow;10        const FontDescriptor = model.FontDescriptor;11        const ImageDescriptor = model.ImageDescriptor;12        const Bytes = model.Bytes;13        const font_count: usize = limits.fonts;14        const image_count: usize = limits.images;15        var cursor: usize = 0;16        try addSlice(&cursor, FontDescriptor, font_count);17        try addSlice(&cursor, Bytes, font_count);18        try addSlice(&cursor, u32, font_count);19        try addSlice(&cursor, u64, std.math.divCeil(usize, font_count, 64) catch unreachable);20        try addSlice(&cursor, ImageDescriptor, image_count);21        try addSlice(&cursor, Bytes, image_count);22        try addSlice(&cursor, u32, image_count);23        try addSlice(&cursor, u64, std.math.divCeil(usize, image_count, 64) catch unreachable);24        const string_bytes = std.math.mul(usize, font_count, family_bytes_per_font) catch return error.CapacityOverflow;25        try addSlice(&cursor, u8, string_bytes);26        try addSlice(&cursor, u8, limits.owned_bytes);27        return .{28            .total_bytes = cursor,29            .font_bytes = std.math.mul(usize, font_count, @sizeOf(FontDescriptor)) catch unreachable,30            .image_bytes = std.math.mul(usize, image_count, @sizeOf(ImageDescriptor)) catch unreachable,31            .string_bytes = string_bytes,32            .owned_bytes = limits.owned_bytes,33        };34    }35};

1pub const Error = error{CapacityOverflow};

1pub const Limits = struct {2    fonts: u32 = 32,3    images: u32 = 16,4    owned_bytes: u32 = 41_328,5};

1pub const Bytes = union(enum) {2    borrowed: []const u8,3    owned: []const u8,45    pub fn slice(self: Bytes) []const u8 {6        return switch (self) {7            .borrowed => |value| value,8            .owned => |value| value,9        };10    }11};

1pub const Error = error{2    FontCapacityExceeded,3    ImageCapacityExceeded,4    OwnedBytesExceeded,5    FamilyTooLong,6    StaleAsset,7    GenerationExhausted,8};

1pub const Font = struct {2    descriptor: FontDescriptor,3    family: []const u8,4    bytes: []const u8,5};

1pub const FontDescriptor = extern struct {2    family_offset: u32 = 0,3    family_len: u32 = 0,4    units_per_em: u16 = 1000,5    weight: u16 = 400,6    width: u8 = 5,7    slant: u8 = 0,8    monospace: u8 = 0,9    color: u8 = 0,10    ascent: f32 = 0,11    descent: f32 = 0,12    line_gap: f32 = 0,13    coverage: [8]u32 = @splat(0),14    face_index: u32 = 0,15};

1pub const Image = struct {2    descriptor: ImageDescriptor,3    bytes: []const u8,4};

1pub const ImageDescriptor = extern struct {2    width: u32 = 0,3    height: u32 = 0,4    format: u16 = 0,5    flags: u16 = 0,6    stride: u32 = 0,7    reserved: u32 = 0,8};

1pub const Kind = enum { font, image };

1pub const Authored = struct {2    face: ?model.AssetHandle,3    synthetic_slant: bool,4    fallback: []const model.AssetHandle,5};

1pub const Coverage = enum(u6) {2    latin,3    cyrillic,4    cjk,5    emoji,6    greek,7    arabic,8    hebrew,9    devanagari,10    other,11};

1pub const Primary = struct {2    face: ?model.AssetHandle,3    synthetic_slant: bool,4};

1pub const Request = struct {2    family: []const u8,3    weight: u16 = 400,4    slant: u8 = 0,5    monospace: bool = false,6    scripts: u64 = 0,7};

1pub const Resolution = struct {2    face: ?model.AssetHandle,3    synthetic_slant: bool,4    fallback: []const model.AssetHandle,5};

1pub const default_table_bytes: usize = 47_104;

1pub const family_bytes_per_font: u32 = 64;

1pub const faces = [_]Face{2    .{3        .family = "Noto Sans",4        .descriptor = .{5            .family_len = "Noto Sans".len,6            .units_per_em = 1000,7            .weight = 400,8            .width = 5,9            .ascent = 1.069,10            .descent = -0.293,11            .coverage = .{ 0xa000020f, 0x00000002, 0, 0, 0, 0, 0, 0 },12        },13        .bytes = noto_bytes,14    },15    .{16        .family = "Iosevka",17        .descriptor = .{18            .family_len = "Iosevka".len,19            .units_per_em = 1000,20            .weight = 400,21            .width = 5,22            .monospace = 1,23            .ascent = 0.965,24            .descent = -0.285,25            .coverage = .{ 0xa000020f, 0x00000002, 0, 0, 0, 0, 0, 0 },26        },27        .bytes = iosevka_bytes,28    },29};

1pub fn authored(registry: *const Registry, family_list: []const u8, weight: u16, slant: u8, fallback_out: []model.AssetHandle) Error!Authored {2    if (fallback_out.len < registry.font_used -| 1) return error.FallbackCapacityExceeded;3    var selected: ?model.AssetHandle = null;4    var used: usize = 0;5    var cursor: usize = 0;6    var monospace = false;7    while (nextFamily(family_list, &cursor)) |raw_family| {8        var decoded: [64]u8 = undefined;9        const family = if (css.token.hasEscape(raw_family))10            css.token.unescape(raw_family, &decoded) orelse continue11        else12            raw_family;13        if (std.ascii.eqlIgnoreCase(family, "monospace")) monospace = true;14        const choice = primary(registry, .{ .family = family, .weight = weight, .slant = slant });15        const face = choice.face orelse continue;16        const found = registry.font(face) catch unreachable;17        if (!std.ascii.eqlIgnoreCase(found.family, family)) continue;18        if (selected == null) {19            selected = face;20        } else if (!std.meta.eql(selected.?, face) and !containsHandle(fallback_out[0..used], face)) {21            fallback_out[used] = face;22            used += 1;23        }24    }25    const face = selected orelse primary(registry, .{26        .family = "",27        .weight = weight,28        .slant = slant,29        .monospace = monospace,30    }).face;31    return .{32        .face = face,33        .synthetic_slant = if (face) |handle| slant != 0 and registry.fonts[handle.index].slant == 0 else false,34        .fallback = fallback_out[0..used],35    };36}

1pub fn bit(value: Coverage) u64 {2    return @as(u64, 1) << @backingInt(value);3}

1/// The first four words use OS/2 Unicode-range positions. Word four bit zero2/// denotes cmap coverage in the assigned emoji pictograph range.3pub fn coverageForScripts(scripts: u64) [8]u32 {4    var mask: [8]u32 = @splat(0);5    if (scripts & bit(.latin) != 0) mask[0] |= 0x2000007f;6    if (scripts & bit(.cyrillic) != 0) mask[0] |= @as(u32, 1) << 9;7    if (scripts & bit(.greek) != 0) mask[0] |= @as(u32, 1) << 7;8    if (scripts & bit(.arabic) != 0) mask[0] |= @as(u32, 1) << 13;9    if (scripts & bit(.hebrew) != 0) mask[0] |= @as(u32, 1) << 11;10    if (scripts & bit(.devanagari) != 0) mask[0] |= @as(u32, 1) << 15;11    if (scripts & bit(.cjk) != 0) {12        mask[0] |= @as(u32, 1) << 28;13        mask[1] |= 0x29df0000;14    }15    if (scripts & bit(.emoji) != 0) mask[4] |= 1;16    return mask;17}

1pub fn primary(registry: *const Registry, request: Request) Primary {2    if (registry.font_used == 0) return .{ .face = null, .synthetic_slant = false };3    const wanted = coverageForScripts(request.scripts);4    var chosen_face: ?model.AssetHandle = null;5    for (registry.fonts, 0..) |_, index| {6        const handle = model.AssetHandle{ .index = @intCast(index), .generation = registry.font_generation[index] };7        if (!registry.hasFont(handle)) continue;8        if (chosen_face) |chosen| {9            if (preferPrimary(registry, handle, chosen, request, wanted)) chosen_face = handle;10        } else chosen_face = handle;11    }12    const face = chosen_face.?;13    return .{14        .face = face,15        .synthetic_slant = request.slant != 0 and registry.fonts[face.index].slant == 0,16    };17}

1pub fn resolve(registry: *const Registry, request: Request, fallback_out: []model.AssetHandle) Error!Resolution {2    const selected = primary(registry, request);3    const face = selected.face orelse return .{ .face = null, .synthetic_slant = false, .fallback = fallback_out[0..0] };4    const fallback = try scriptFallbacks(registry, request.scripts, &.{face}, fallback_out);5    return .{6        .face = face,7        .synthetic_slant = selected.synthetic_slant,8        .fallback = fallback,9    };10}

1/// Orders faces outside an authored chain for one itemized script run.2pub fn scriptFallbacks(registry: *const Registry, scripts: u64, excluded: []const model.AssetHandle, fallback_out: []model.AssetHandle) Error![]const model.AssetHandle {3    const wanted = coverageForScripts(scripts);4    var wanted_bits: usize = 0;5    for (wanted) |word| wanted_bits += @popCount(word);6    const bucket_count = wanted_bits + 1;7    var counts: [257]u32 = undefined;8    @memset(counts[0..bucket_count], 0);9    for (registry.fonts, 0..) |_, index| {10        const handle = model.AssetHandle{ .index = @intCast(index), .generation = registry.font_generation[index] };11        if (!registry.hasFont(handle) or containsHandle(excluded, handle)) continue;12        counts[overlap(registry.fonts[index].coverage, wanted)] += 1;13    }14    var starts: [257]u32 = undefined;15    var used: u32 = 0;16    var score: usize = bucket_count;17    while (score > 0) {18        score -= 1;19        starts[score] = used;20        used += counts[score];21    }22    if (fallback_out.len < used) return error.FallbackCapacityExceeded;23    for (registry.fonts, 0..) |_, index| {24        const handle = model.AssetHandle{ .index = @intCast(index), .generation = registry.font_generation[index] };25        if (!registry.hasFont(handle) or containsHandle(excluded, handle)) continue;26        const rank = overlap(registry.fonts[index].coverage, wanted);27        fallback_out[starts[rank]] = handle;28        starts[rank] += 1;29    }30    return fallback_out[0..used];31}

1pub fn scriptsFromRuns(runs: []const unicode.ScriptRun, emoji_present: bool) u64 {2    var mask: u64 = if (emoji_present) bit(.emoji) else 0;3    for (runs) |run| {4        mask |= switch (run.script) {5            .latin => bit(.latin),6            .cyrillic => bit(.cyrillic),7            .han, .hiragana, .katakana, .hangul, .bopomofo => bit(.cjk),8            .greek => bit(.greek),9            .arabic => bit(.arabic),10            .hebrew => bit(.hebrew),11            .devanagari => bit(.devanagari),12            .common, .inherited, .unknown => 0,13            else => bit(.other),14        };15    }16    return mask;17}

1const capacity = @import("capacity.zig");2const model = @import("model.zig");3const registry = @import("registry.zig");4const resolution = @import("resolve.zig");5const embedded = @import("embedded.zig");67pub const AssetHandle = model.AssetHandle;8pub const FontDescriptor = model.FontDescriptor;9pub const ImageDescriptor = model.ImageDescriptor;10pub const Bytes = model.Bytes;11pub const Kind = model.Kind;12pub const Error = model.Error;13pub const Font = model.Font;14pub const Image = model.Image;15pub const Limits = capacity.Limits;16pub const Capacity = capacity.Capacity;17pub const CapacityError = capacity.Error;18pub const family_bytes_per_font = capacity.family_bytes_per_font;19pub const default_table_bytes = capacity.default_table_bytes;20pub const Registry = registry.Registry;21pub const Coverage = resolution.Coverage;22pub const coverageBit = resolution.bit;23pub const coverageForScripts = resolution.coverageForScripts;24pub const scriptsFromRuns = resolution.scriptsFromRuns;25pub const FontRequest = resolution.Request;26pub const FontResolution = resolution.Resolution;27pub const FontPrimary = resolution.Primary;28pub const primaryFont = resolution.primary;29pub const FontAuthored = resolution.Authored;30pub const resolveAuthored = resolution.authored;31pub const scriptFallbacks = resolution.scriptFallbacks;32pub const Embedded = embedded.Embedded;33pub const embedded_faces = embedded.faces;34pub const openWithEmbedded = embedded.Embedded.open;35pub const resolveFont = resolution.resolve;

1pub const asset = @import("asset/root.zig");