tiny.filigree.FallbackContext

1pub const Context = struct {2    allocator: Allocator,3    shaper: shape.Context,4    script_context: unicode_data.ScriptRunContext,5    segment_output: shape.Output,6    workspace: workspace_mod.Workspace,78    pub const Options: type = ContextOptions;910    pub fn init(allocator: Allocator, options: Options) !Context {11        var workspace = try workspace_mod.Workspace.init(allocator, .{12            .max_source_units = options.script_runs.max_source_units,13        });14        errdefer workspace.deinit(allocator);15        workspace.activate();16        var script_context = try unicode_data.ScriptRunContext.init(allocator, options.script_runs);17        errdefer script_context.deinit(allocator);18        script_context.activate();19        return .{20            .allocator = allocator,21            .shaper = shape.Context.init(allocator, .{}),22            .script_context = script_context,23            .segment_output = try shape.Output.init(allocator, options.output),24            .workspace = workspace,25        };26    }2728    pub fn deinit(self: *Context) void {29        self.workspace.deinit(self.allocator);30        self.segment_output.deinit(self.allocator);31        self.script_context.deinit(self.allocator);32        self.shaper.deinit();33        self.* = undefined;34    }3536    pub fn reset(self: *Context) void {37        self.workspace.reset();38        self.segment_output.clearRetainingCapacity();39        self.script_context.reset();40        self.shaper.reset();41    }4243    pub fn scriptRunStatus(self: *const Context) unicode_data.ScriptRunStatus {44        return self.script_context.status();45    }4647    pub fn workspaceStatus(self: *const Context) workspace_mod.Status {48        return self.workspace.status();49    }5051    pub fn shapeRun(self: *Context, input: Input, output: *shape.Output) !void {52        return self.shapeRunWithSegments(input, output, self.allocator, null);53    }5455    /// Reported segments grow through segment_allocator and must be released through it.56    pub fn shapeRunSegmented(57        self: *Context,58        input: Input,59        output: *shape.Output,60        segment_allocator: Allocator,61        segments: *std.ArrayListUnmanaged(Segment),62    ) !void {63        return self.shapeRunWithSegments(input, output, segment_allocator, segments);64    }6566    fn shapeRunWithSegments(67        self: *Context,68        input: Input,69        output: *shape.Output,70        segment_allocator: Allocator,71        segments: ?*std.ArrayListUnmanaged(Segment),72    ) !void {73        const automatic_script = usesAutomaticScript(input.base);74        if (input.candidates.len == 0 and !automatic_script) {75            if (segments) |items| items.clearRetainingCapacity();76            try self.shaper.shapeRun(input.base, output);77            if (segments != null) {78                try appendOutputSegment(segment_allocator, segments, try sourceRange(input.base), 0, false, 0, output.glyphs.items.len);79            }80            return;81        }8283        const source_byte_len = try input.base.text.byteLen();84        if (source_byte_len > std.math.maxInt(u32)) return error.SourceTooLong;85        const remaining_source_bytes: usize = std.math.maxInt(u32) - input.base.source_offset;86        if (source_byte_len > remaining_source_bytes) return error.SourceTooLong;87        try self.workspace.begin(input.base.text.scalarCapacityHint());8889        output.clearRetainingCapacity();90        self.segment_output.clearRetainingCapacity();91        self.script_context.reset();92        self.shaper.reset();93        if (segments) |items| items.clearRetainingCapacity();94        errdefer output.clearRetainingCapacity();95        errdefer self.reset();96        errdefer if (segments) |items| items.clearRetainingCapacity();9798        output.direction = input.base.direction;99        output.writing_mode = input.base.writing_mode;100        output.output_order = input.base.output_order;101102        if (source_byte_len == 0) return;103104        try self.collectClusters(input.base.text);105        if (automatic_script) try self.assignScripts(input.base.text);106        const uses_fallback = self.assignCandidates(input);107        if (!uses_fallback and !automatic_script) {108            try self.shaper.shapeRun(input.base, output);109            try appendOutputSegment(110                segment_allocator,111                segments,112                .{113                    .start = input.base.source_offset,114                    .end = @intCast(input.base.source_offset + source_byte_len),115                },116                0,117                false,118                0,119                output.glyphs.items.len,120            );121            return;122        }123124        try self.buildRanges(automatic_script);125        if (input.base.direction == .rtl and input.base.output_order == .visual) {126            var range_index = self.workspace.ranges.items.len;127            while (range_index > 0) {128                range_index -= 1;129                try self.shapeSegment(input, self.workspace.ranges.items[range_index], output, segment_allocator, segments);130            }131        } else {132            for (self.workspace.ranges.items) |range| {133                try self.shapeSegment(input, range, output, segment_allocator, segments);134            }135        }136    }137138    fn assignScripts(self: *Context, source: shape.Source) !void {139        const runs = try self.script_context.itemize(.{ .text = source });140        var run_index: usize = 0;141        for (self.workspace.clusters.items) |*cluster| {142            while (run_index + 1 < runs.len and cluster.source.start >= runs[run_index].source.end) run_index += 1;143            cluster.script = if (run_index < runs.len and cluster.source.start >= runs[run_index].source.start and cluster.source.end <= runs[run_index].source.end)144                runs[run_index].script145            else146                .unknown;147        }148    }149150    fn collectClusters(self: *Context, source: shape.Source) !void {151        self.workspace.scalars.clearRetainingCapacity();152        self.workspace.clusters.clearRetainingCapacity();153        var grapheme_state: unicode_data.GraphemeState = .{};154        var iterator = try unicode_data.SourceIterator.init(source, 0);155        while (try iterator.next()) |scalar| {156            try self.appendScalar(.{157                .codepoint = scalar.codepoint,158                .start = scalar.source.start,159                .end = scalar.source.end,160            }, &grapheme_state);161        }162        self.mergeJoiningClusters();163    }164165    fn appendScalar(self: *Context, scalar: Scalar, grapheme_state: *unicode_data.GraphemeState) !void {166        const scalar_index: u32 = @intCast(self.workspace.scalars.items.len);167        std.debug.assert(self.workspace.scalars.items.len < self.workspace.scalars.capacity);168        self.workspace.scalars.appendAssumeCapacity(scalar);169        const scalar_end = scalar_index + 1;170        const merge = grapheme_state.consume(scalar.codepoint);171        if (self.workspace.clusters.items.len == 0 or !merge) {172            std.debug.assert(self.workspace.clusters.items.len < self.workspace.clusters.capacity);173            self.workspace.clusters.appendAssumeCapacity(.{174                .source = .{ .start = scalar.start, .end = scalar.end },175                .scalars = .{ .start = scalar_index, .end = scalar_end },176            });177            return;178        }179        const last = &self.workspace.clusters.items[self.workspace.clusters.items.len - 1];180        last.source.end = scalar.end;181        last.scalars.end = scalar_end;182    }183184    fn mergeJoiningClusters(self: *Context) void {185        if (self.workspace.clusters.items.len < 2) return;186        var write_index: usize = 0;187        var read_index: usize = 1;188        while (read_index < self.workspace.clusters.items.len) : (read_index += 1) {189            if (self.clustersJoin(self.workspace.clusters.items[write_index], self.workspace.clusters.items[read_index])) {190                self.workspace.clusters.items[write_index].source.end = self.workspace.clusters.items[read_index].source.end;191                self.workspace.clusters.items[write_index].scalars.end = self.workspace.clusters.items[read_index].scalars.end;192            } else {193                write_index += 1;194                if (write_index != read_index) self.workspace.clusters.items[write_index] = self.workspace.clusters.items[read_index];195            }196        }197        self.workspace.clusters.shrinkRetainingCapacity(write_index + 1);198    }199200    fn clustersJoin(self: *const Context, left: SourceCluster, right: SourceCluster) bool {201        const previous = self.lastJoiningType(left) orelse return false;202        const next = self.firstJoiningType(right) orelse return false;203        return shape.joiningTypesConnect(previous, next);204    }205206    fn firstJoiningType(self: *const Context, cluster: SourceCluster) ?shape.JoiningType {207        var scalar_index: usize = @intCast(cluster.scalars.start);208        const scalar_end: usize = @intCast(cluster.scalars.end);209        while (scalar_index < scalar_end) : (scalar_index += 1) {210            const found = shape.joiningType(self.workspace.scalars.items[scalar_index].codepoint);211            if (found != .transparent) return found;212        }213        return null;214    }215216    fn lastJoiningType(self: *const Context, cluster: SourceCluster) ?shape.JoiningType {217        var scalar_index: usize = @intCast(cluster.scalars.end);218        const scalar_start: usize = @intCast(cluster.scalars.start);219        while (scalar_index > scalar_start) {220            scalar_index -= 1;221            const found = shape.joiningType(self.workspace.scalars.items[scalar_index].codepoint);222            if (found != .transparent) return found;223        }224        return null;225    }226227    fn assignCandidates(self: *Context, input: Input) bool {228        var uses_fallback = false;229        for (self.workspace.clusters.items) |*cluster| {230            const selected = self.bestCandidate(input, cluster.*);231            cluster.candidate_index = selected.candidate_index;232            cluster.missing_everywhere = selected.missing_everywhere;233            uses_fallback = uses_fallback or cluster.candidate_index != 0 or cluster.missing_everywhere;234        }235        return uses_fallback;236    }237238    fn bestCandidate(self: *const Context, input: Input, cluster: SourceCluster) CandidateSelection {239        if (self.clusterCoveredBy(candidateAt(input, 0), cluster)) return .{ .candidate_index = 0, .missing_everywhere = false };240        for (input.candidates, 0..) |_, candidate_index| {241            const selected_index = candidate_index + 1;242            if (self.clusterCoveredBy(candidateAt(input, selected_index), cluster)) {243                return .{ .candidate_index = selected_index, .missing_everywhere = false };244            }245        }246        return .{ .candidate_index = 0, .missing_everywhere = true };247    }248249    fn clusterCoveredBy(self: *const Context, candidate: SelectedCandidate, cluster: SourceCluster) bool {250        var scalar_index: usize = @intCast(cluster.scalars.start);251        const scalar_end: usize = @intCast(cluster.scalars.end);252        while (scalar_index < scalar_end) {253            const scalar = self.workspace.scalars.items[scalar_index];254            if (scalar_index + 1 < scalar_end) {255                const next = self.workspace.scalars.items[scalar_index + 1];256                if (isVariationSelector(next.codepoint)) {257                    if (candidate.font.face.glyphIdForVariation(scalar.codepoint, next.codepoint)) |glyph_id| {258                        if (glyph_id == 0) return false;259                        scalar_index += 2;260                        continue;261                    }262                }263            }264            if (!coverageIgnoresScalar(scalar.codepoint) and candidate.font.face.glyphId(scalar.codepoint) == 0) return false;265            scalar_index += 1;266        }267        return true;268    }269270    fn buildRanges(self: *Context, split_by_script: bool) !void {271        self.workspace.ranges.clearRetainingCapacity();272        var cluster_start: usize = 0;273        while (cluster_start < self.workspace.clusters.items.len) {274            const candidate_index = self.workspace.clusters.items[cluster_start].candidate_index;275            const missing_everywhere = self.workspace.clusters.items[cluster_start].missing_everywhere;276            const range_script = self.workspace.clusters.items[cluster_start].script;277            var cluster_end = cluster_start + 1;278            while (cluster_end < self.workspace.clusters.items.len and279                self.workspace.clusters.items[cluster_end].candidate_index == candidate_index and280                self.workspace.clusters.items[cluster_end].missing_everywhere == missing_everywhere and281                (!split_by_script or self.workspace.clusters.items[cluster_end].script == range_script))282            {283                cluster_end += 1;284            }285            std.debug.assert(self.workspace.ranges.items.len < self.workspace.ranges.capacity);286            self.workspace.ranges.appendAssumeCapacity(.{287                .cluster_start = @intCast(cluster_start),288                .cluster_end = @intCast(cluster_end),289                .candidate_index = candidate_index,290                .missing_everywhere = missing_everywhere,291                .script = range_script,292            });293            cluster_start = cluster_end;294        }295    }296297    fn shapeSegment(298        self: *Context,299        input: Input,300        range: SegmentRange,301        output: *shape.Output,302        segment_allocator: Allocator,303        segments: ?*std.ArrayListUnmanaged(Segment),304    ) !void {305        const cluster_start: usize = @intCast(range.cluster_start);306        const cluster_end: usize = @intCast(range.cluster_end);307        const source_start = self.workspace.clusters.items[cluster_start].source.start;308        const source_end = self.workspace.clusters.items[cluster_end - 1].source.end;309        const selected = candidateAt(input, range.candidate_index);310        const glyph_start = output.glyphs.items.len;311        var segment_input = input.base;312        segment_input.font = selected.font;313        segment_input.variations = selected.variations;314        segment_input.text = sliceSource(input.base.text, source_start, source_end);315        segment_input.source_offset = try addSourceOffset(input.base.source_offset, source_start);316        segment_input.pre_context = null;317        segment_input.post_context = null;318319        if (usesAutomaticScript(input.base)) {320            const script_tags = unicode_data.scriptOpenTypeTags(range.script);321            segment_input.script = script_tags.tags[0];322            segment_input.script_tags = script_tags.slice();323            try self.shaper.shapeRun(segment_input, &self.segment_output);324        } else {325            try self.shaper.shapeRun(segment_input, &self.segment_output);326        }327        try appendSegmentOutput(output, &self.segment_output);328        try appendOutputSegment(329            segment_allocator,330            segments,331            .{332                .start = try addSourceOffset(input.base.source_offset, source_start),333                .end = try addSourceOffset(input.base.source_offset, source_end),334            },335            range.candidate_index,336            range.missing_everywhere,337            glyph_start,338            output.glyphs.items.len,339        );340    }341};

1pub const FallbackContext = fallback.Context;