read_fonts/tables/colr/

closure.rs

//! computing closure for the colr table

use font_types::{GlyphId, GlyphId16};

use crate::{collections::IntSet, tables::variations::NO_VARIATION_INDEX, ResolveOffset};

use super::{
    Clip, ClipBox, ClipBoxFormat2, ClipList, ColorLine, ColorStop, Colr, Paint, PaintColrGlyph,
    PaintColrLayers, PaintComposite, PaintGlyph, PaintLinearGradient, PaintRadialGradient,
    PaintRotate, PaintRotateAroundCenter, PaintScale, PaintScaleAroundCenter, PaintScaleUniform,
    PaintScaleUniformAroundCenter, PaintSkew, PaintSkewAroundCenter, PaintSolid,
    PaintSweepGradient, PaintTransform, PaintTranslate, PaintVarLinearGradient,
    PaintVarRadialGradient, PaintVarRotate, PaintVarRotateAroundCenter, PaintVarScale,
    PaintVarScaleAroundCenter, PaintVarScaleUniform, PaintVarScaleUniformAroundCenter,
    PaintVarSkew, PaintVarSkewAroundCenter, PaintVarSolid, PaintVarSweepGradient,
    PaintVarTransform, PaintVarTranslate, VarAffine2x3, VarColorLine, VarColorStop,
};

impl<'a> Colr<'a> {
    //Collect the transitive closure of V0 palette indices needed for all of the input glyphs set
    //It's similar to closure glyphs but in a separate fn, because v1 closure might adds more v0 glyphs, so this fn needs to be called after v1 closure
    pub fn v0_closure_palette_indices(
        &self,
        glyph_set: &IntSet<GlyphId>,
        palette_indices: &mut IntSet<u16>,
    ) {
        let Some(Ok(records)) = self.base_glyph_records() else {
            return;
        };
        for glyph_id in glyph_set.iter() {
            let Ok(glyph_id) = glyph_id.try_into() else {
                continue;
            };
            let record = match records.binary_search_by(|rec| rec.glyph_id().cmp(&glyph_id)) {
                Ok(idx) => records[idx],
                _ => continue,
            };
            let start = record.first_layer_index() as usize;
            let end = start + record.num_layers() as usize;
            for layer_index in start..=end {
                if let Ok((_gid, palette_id)) = self.v0_layer(layer_index) {
                    palette_indices.insert(palette_id);
                }
            }
        }
    }

    /// Collect the transitive closure of v1 glyphs,layer/paletted indices and variation/delta set indices for COLRv1
    pub fn v1_closure(
        &self,
        glyph_set: &mut IntSet<GlyphId>,
        layer_indices: &mut IntSet<u32>,
        palette_indices: &mut IntSet<u16>,
        variation_indices: &mut IntSet<u32>,
        delta_set_indices: &mut IntSet<u32>,
    ) {
        if self.version() < 1 {
            return;
        }

        let mut c =
            Colrv1ClosureContext::new(layer_indices, palette_indices, variation_indices, self);
        if let Some(Ok(base_glyph_list)) = self.base_glyph_list() {
            let base_glyph_records = base_glyph_list.base_glyph_paint_records();
            let offset_data = base_glyph_list.offset_data();
            for paint_record in base_glyph_records {
                let gid = paint_record.glyph_id();
                if !glyph_set.contains(GlyphId::from(gid)) {
                    continue;
                }
                if let Ok(paint) = paint_record.paint(offset_data) {
                    c.dispatch(&paint);
                }
            }

            glyph_set.union(&c.glyph_set);
        }

        if let Some(Ok(clip_list)) = self.clip_list() {
            c.glyph_set.union(glyph_set);
            for clip_record in clip_list.clips() {
                clip_record.v1_closure(&mut c, &clip_list);
            }
        }

        //when a DeltaSetIndexMap is included, collected variation indices are actually delta set indices, we need to map them into variation indices
        if let Some(Ok(var_index_map)) = self.var_index_map() {
            delta_set_indices.extend(variation_indices.iter());
            variation_indices.clear();
            for idx in delta_set_indices.iter() {
                if let Ok(var_idx) = var_index_map.get(idx) {
                    let var_idx = ((var_idx.outer as u32) << 16) + var_idx.inner as u32;
                    variation_indices.insert(var_idx);
                }
            }
        }
    }

    /// Collect the transitive closure of V0 glyphs needed for all of the input glyphs set
    pub fn v0_closure_glyphs(
        &self,
        glyph_set: &IntSet<GlyphId>,
        glyphset_colrv0: &mut IntSet<GlyphId>,
    ) {
        glyphset_colrv0.union(glyph_set);
        let Some(Ok(records)) = self.base_glyph_records() else {
            return;
        };
        for glyph_id in glyph_set.iter() {
            let Ok(glyph_id) = glyph_id.try_into() else {
                continue;
            };
            let record = match records.binary_search_by(|rec| rec.glyph_id().cmp(&glyph_id)) {
                Ok(idx) => records[idx],
                _ => continue,
            };
            let start = record.first_layer_index() as usize;
            let end = start + record.num_layers() as usize;
            for layer_index in start..=end {
                if let Ok((gid, _palette_id)) = self.v0_layer(layer_index) {
                    glyphset_colrv0.insert(GlyphId::from(gid));
                }
            }
        }
    }
}

struct Colrv1ClosureContext<'a> {
    glyph_set: IntSet<GlyphId>,
    layer_indices: &'a mut IntSet<u32>,
    palette_indices: &'a mut IntSet<u16>,
    variation_indices: &'a mut IntSet<u32>,
    colr: &'a Colr<'a>,
    nesting_level_left: u8,
    visited_paints: IntSet<u32>,
    colr_head: usize,
}

impl<'a> Colrv1ClosureContext<'a> {
    pub fn new(
        layer_indices: &'a mut IntSet<u32>,
        palette_indices: &'a mut IntSet<u16>,
        variation_indices: &'a mut IntSet<u32>,
        colr: &'a Colr,
    ) -> Self {
        let colr_head = colr.offset_data().as_bytes().as_ptr() as usize;
        Self {
            glyph_set: IntSet::empty(),
            layer_indices,
            palette_indices,
            variation_indices,
            colr,
            nesting_level_left: 64,
            visited_paints: IntSet::empty(),
            colr_head,
        }
    }

    fn dispatch(&mut self, paint: &Paint) {
        if self.nesting_level_left == 0 {
            return;
        }

        if self.paint_visited(paint) {
            return;
        }
        self.nesting_level_left -= 1;
        paint.v1_closure(self);
        self.nesting_level_left += 1;
    }

    fn paint_visited(&mut self, paint: &Paint) -> bool {
        let offset = (paint.offset_data().as_bytes().as_ptr() as usize - self.colr_head) as u32;
        if self.visited_paints.contains(offset) {
            return true;
        }

        self.visited_paints.insert(offset);
        false
    }

    fn add_layer_indices(&mut self, first_layer_index: u32, last_layer_index: u32) {
        self.layer_indices
            .insert_range(first_layer_index..=last_layer_index);
    }

    fn add_palette_index(&mut self, palette_index: u16) {
        self.palette_indices.insert(palette_index);
    }

    fn add_variation_indices(&mut self, var_index_base: u32, num_vars: u8) {
        if num_vars == 0 || var_index_base == NO_VARIATION_INDEX {
            return;
        }

        let last_var_index = var_index_base + num_vars as u32 - 1;
        self.variation_indices
            .insert_range(var_index_base..=last_var_index);
    }

    fn add_glyph_id(&mut self, gid: GlyphId16) {
        self.glyph_set.insert(GlyphId::from(gid));
    }
}

impl ColorStop {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        c.add_palette_index(self.palette_index());
    }
}

impl VarColorStop {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        c.add_palette_index(self.palette_index());
        c.add_variation_indices(self.var_index_base(), 2);
    }
}

impl<'a> ColorLine<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        for colorstop in self.color_stops() {
            colorstop.v1_closure(c);
        }
    }
}

impl<'a> VarColorLine<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        for var_colorstop in self.color_stops() {
            var_colorstop.v1_closure(c);
        }
    }
}

impl<'a> Paint<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        match self {
            Self::ColrLayers(item) => item.v1_closure(c),
            Self::Solid(item) => item.v1_closure(c),
            Self::VarSolid(item) => item.v1_closure(c),
            Self::LinearGradient(item) => item.v1_closure(c),
            Self::VarLinearGradient(item) => item.v1_closure(c),
            Self::RadialGradient(item) => item.v1_closure(c),
            Self::VarRadialGradient(item) => item.v1_closure(c),
            Self::SweepGradient(item) => item.v1_closure(c),
            Self::VarSweepGradient(item) => item.v1_closure(c),
            Self::Glyph(item) => item.v1_closure(c),
            Self::ColrGlyph(item) => item.v1_closure(c),
            Self::Transform(item) => item.v1_closure(c),
            Self::VarTransform(item) => item.v1_closure(c),
            Self::Translate(item) => item.v1_closure(c),
            Self::VarTranslate(item) => item.v1_closure(c),
            Self::Scale(item) => item.v1_closure(c),
            Self::VarScale(item) => item.v1_closure(c),
            Self::ScaleAroundCenter(item) => item.v1_closure(c),
            Self::VarScaleAroundCenter(item) => item.v1_closure(c),
            Self::ScaleUniform(item) => item.v1_closure(c),
            Self::VarScaleUniform(item) => item.v1_closure(c),
            Self::ScaleUniformAroundCenter(item) => item.v1_closure(c),
            Self::VarScaleUniformAroundCenter(item) => item.v1_closure(c),
            Self::Rotate(item) => item.v1_closure(c),
            Self::VarRotate(item) => item.v1_closure(c),
            Self::RotateAroundCenter(item) => item.v1_closure(c),
            Self::VarRotateAroundCenter(item) => item.v1_closure(c),
            Self::Skew(item) => item.v1_closure(c),
            Self::VarSkew(item) => item.v1_closure(c),
            Self::SkewAroundCenter(item) => item.v1_closure(c),
            Self::VarSkewAroundCenter(item) => item.v1_closure(c),
            Self::Composite(item) => item.v1_closure(c),
        }
    }
}

impl<'a> PaintColrLayers<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        let num_layers = self.num_layers();
        if num_layers == 0 {
            return;
        }

        let Some(Ok(layer_list)) = c.colr.layer_list() else {
            return;
        };
        let first_layer_index = self.first_layer_index();
        let last_layer_index = first_layer_index + num_layers as u32 - 1;
        c.add_layer_indices(first_layer_index, last_layer_index);

        let offset_data = layer_list.offset_data();
        for layer_index in first_layer_index..=last_layer_index {
            if let Some(paint_offset) = layer_list.paint_offsets().get(layer_index as usize) {
                if let Ok(paint) = paint_offset.get().resolve::<Paint>(offset_data) {
                    c.dispatch(&paint);
                }
            }
        }
    }
}

impl<'a> PaintSolid<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        c.add_palette_index(self.palette_index());
    }
}

impl<'a> PaintVarSolid<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        c.add_palette_index(self.palette_index());
        c.add_variation_indices(self.var_index_base(), 1);
    }
}

impl<'a> PaintLinearGradient<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(colorline) = self.color_line() {
            colorline.v1_closure(c);
        }
    }
}

impl<'a> PaintVarLinearGradient<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(var_colorline) = self.color_line() {
            var_colorline.v1_closure(c);
        }
        c.add_variation_indices(self.var_index_base(), 6);
    }
}

impl<'a> PaintRadialGradient<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(colorline) = self.color_line() {
            colorline.v1_closure(c);
        }
    }
}

impl<'a> PaintVarRadialGradient<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(var_colorline) = self.color_line() {
            var_colorline.v1_closure(c);
        }
        c.add_variation_indices(self.var_index_base(), 6);
    }
}

impl<'a> PaintSweepGradient<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(colorline) = self.color_line() {
            colorline.v1_closure(c);
        }
    }
}

impl<'a> PaintVarSweepGradient<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(var_colorline) = self.color_line() {
            var_colorline.v1_closure(c);
        }
        c.add_variation_indices(self.var_index_base(), 4);
    }
}

impl<'a> PaintGlyph<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        c.add_glyph_id(self.glyph_id());
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintColrGlyph<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        let glyph_id = self.glyph_id();
        let Some(Ok(list)) = c.colr.base_glyph_list() else {
            return;
        };
        let records = list.base_glyph_paint_records();
        let record = match records.binary_search_by(|rec| rec.glyph_id().cmp(&glyph_id)) {
            Ok(ix) => &records[ix],
            _ => return,
        };
        if let Ok(paint) = record.paint(list.offset_data()) {
            c.add_glyph_id(glyph_id);
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintTransform<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> VarAffine2x3<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        c.add_variation_indices(self.var_index_base(), 6);
    }
}

impl<'a> PaintVarTransform<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            if let Ok(affine2x3) = self.transform() {
                affine2x3.v1_closure(c);
            }
        }
    }
}

impl<'a> PaintTranslate<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarTranslate<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 2);
        }
    }
}

impl<'a> PaintScale<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarScale<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 2);
        }
    }
}

impl<'a> PaintScaleAroundCenter<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarScaleAroundCenter<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 4);
        }
    }
}

impl<'a> PaintScaleUniform<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarScaleUniform<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 1);
        }
    }
}

impl<'a> PaintScaleUniformAroundCenter<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarScaleUniformAroundCenter<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 3);
        }
    }
}

impl<'a> PaintRotate<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarRotate<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 1);
        }
    }
}

impl<'a> PaintRotateAroundCenter<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarRotateAroundCenter<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 3);
        }
    }
}

impl<'a> PaintSkew<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarSkew<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 2);
        }
    }
}

impl<'a> PaintSkewAroundCenter<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
        }
    }
}

impl<'a> PaintVarSkewAroundCenter<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(paint) = self.paint() {
            c.dispatch(&paint);
            c.add_variation_indices(self.var_index_base(), 4);
        }
    }
}

impl<'a> PaintComposite<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Ok(source_paint) = self.source_paint() {
            c.dispatch(&source_paint);
        }

        if let Ok(backdrop_paint) = self.backdrop_paint() {
            c.dispatch(&backdrop_paint);
        }
    }
}

impl Clip {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext, clip_list: &ClipList) {
        let Ok(clip_box) = self.clip_box(clip_list.offset_data()) else {
            return;
        };
        //TODO: replace below code when we have intersects(Range) available for int-set
        let mut included_gids = IntSet::empty();
        let start_id = GlyphId::from(self.start_glyph_id());
        let end_id = GlyphId::from(self.end_glyph_id());
        included_gids.insert_range(start_id..=end_id);
        included_gids.intersect(&c.glyph_set);

        if included_gids.is_empty() {
            return;
        }
        clip_box.v1_closure(c);
    }
}

impl<'a> ClipBox<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        if let Self::Format2(item) = self {
            item.v1_closure(c)
        }
    }
}

impl<'a> ClipBoxFormat2<'a> {
    fn v1_closure(&self, c: &mut Colrv1ClosureContext) {
        c.add_variation_indices(self.var_index_base(), 4);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{FontRef, GlyphId, TableProvider};

    #[test]
    fn test_colr_v0_closure() {
        let font = FontRef::new(font_test_data::COLRV0V1_VARIABLE).unwrap();
        let colr = font.colr().unwrap();

        let mut input_glyph_set = IntSet::empty();
        input_glyph_set.insert(GlyphId::new(168));

        let mut glyph_set_colred = IntSet::empty();

        colr.v0_closure_glyphs(&input_glyph_set, &mut glyph_set_colred);
        assert_eq!(glyph_set_colred.len(), 9);
        assert!(glyph_set_colred.contains(GlyphId::new(5)));
        assert!(glyph_set_colred.contains(GlyphId::new(168)));
        assert!(glyph_set_colred.contains(GlyphId::new(170)));
        assert!(glyph_set_colred.contains(GlyphId::new(171)));
        assert!(glyph_set_colred.contains(GlyphId::new(172)));
        assert!(glyph_set_colred.contains(GlyphId::new(173)));
        assert!(glyph_set_colred.contains(GlyphId::new(174)));
        assert!(glyph_set_colred.contains(GlyphId::new(175)));
        assert!(glyph_set_colred.contains(GlyphId::new(176)));

        let mut palette_indices = IntSet::empty();
        colr.v0_closure_palette_indices(&glyph_set_colred, &mut palette_indices);
        assert_eq!(palette_indices.len(), 8);
        assert!(palette_indices.contains(0));
        assert!(palette_indices.contains(1));
        assert!(palette_indices.contains(2));
        assert!(palette_indices.contains(3));
        assert!(palette_indices.contains(4));
        assert!(palette_indices.contains(5));
        assert!(palette_indices.contains(6));
        assert!(palette_indices.contains(10));
    }

    #[test]
    fn test_colr_v0_closure_not_found() {
        let font = FontRef::new(font_test_data::COLRV0V1_VARIABLE).unwrap();
        let colr = font.colr().unwrap();

        let mut input_glyph_set = IntSet::empty();
        input_glyph_set.insert(GlyphId::new(8));

        let mut glyph_set_colred = IntSet::empty();

        colr.v0_closure_glyphs(&input_glyph_set, &mut glyph_set_colred);
        assert_eq!(glyph_set_colred.len(), 1);
        assert!(glyph_set_colred.contains(GlyphId::new(8)));
    }

    #[test]
    fn test_colr_v1_closure_no_var() {
        let font = FontRef::new(font_test_data::COLRV0V1_VARIABLE).unwrap();
        let colr = font.colr().unwrap();

        let mut glyph_set = IntSet::empty();
        glyph_set.insert(GlyphId::new(220));
        glyph_set.insert(GlyphId::new(120));

        let mut layer_indices = IntSet::empty();
        let mut palette_indices = IntSet::empty();
        let mut variation_indices = IntSet::empty();
        let mut delta_set_indices = IntSet::empty();

        colr.v1_closure(
            &mut glyph_set,
            &mut layer_indices,
            &mut palette_indices,
            &mut variation_indices,
            &mut delta_set_indices,
        );

        assert_eq!(glyph_set.len(), 6);
        assert!(glyph_set.contains(GlyphId::new(6)));
        assert!(glyph_set.contains(GlyphId::new(7)));
        assert!(glyph_set.contains(GlyphId::new(220)));
        assert!(glyph_set.contains(GlyphId::new(3)));
        assert!(glyph_set.contains(GlyphId::new(2)));
        assert!(glyph_set.contains(GlyphId::new(120)));

        assert_eq!(palette_indices.len(), 5);
        assert!(palette_indices.contains(0));
        assert!(palette_indices.contains(4));
        assert!(palette_indices.contains(10));
        assert!(palette_indices.contains(11));
        assert!(palette_indices.contains(12));

        assert_eq!(layer_indices.len(), 2);
        assert!(layer_indices.contains(0));
        assert!(layer_indices.contains(1));

        assert!(variation_indices.is_empty());
        assert!(delta_set_indices.is_empty());
    }

    #[test]
    fn test_colr_v1_closure_w_var() {
        let font = FontRef::new(font_test_data::COLRV0V1_VARIABLE).unwrap();
        let colr = font.colr().unwrap();

        let mut glyph_set = IntSet::empty();
        glyph_set.insert(GlyphId::new(109));

        let mut layer_indices = IntSet::empty();
        let mut palette_indices = IntSet::empty();
        let mut variation_indices = IntSet::empty();
        let mut delta_set_indices = IntSet::empty();

        colr.v1_closure(
            &mut glyph_set,
            &mut layer_indices,
            &mut palette_indices,
            &mut variation_indices,
            &mut delta_set_indices,
        );

        assert_eq!(glyph_set.len(), 2);
        assert!(glyph_set.contains(GlyphId::new(3)));
        assert!(glyph_set.contains(GlyphId::new(109)));

        assert_eq!(palette_indices.len(), 2);
        assert!(palette_indices.contains(1));
        assert!(palette_indices.contains(4));

        assert!(layer_indices.is_empty());

        assert_eq!(delta_set_indices.len(), 6);
        assert!(delta_set_indices.contains(51));
        assert!(delta_set_indices.contains(52));
        assert!(delta_set_indices.contains(53));
        assert!(delta_set_indices.contains(54));
        assert!(delta_set_indices.contains(55));
        assert!(delta_set_indices.contains(56));

        assert_eq!(variation_indices.len(), 6);
        assert!(variation_indices.contains(0x160000_u32));
        assert!(variation_indices.contains(0x170000_u32));
        assert!(variation_indices.contains(0x180000_u32));
        assert!(variation_indices.contains(0x190000_u32));
        assert!(variation_indices.contains(0x1A0000_u32));
        assert!(variation_indices.contains(0x1B0000_u32));
    }
}