Accessing all the layers, including ones hidden in GroupLayers

[HughHoyland]

Here's a piece of code I wrote to store "indexes" (paths, to be precise) into a Layers tree.

I was unfortunate enough to have to work with a map that had multiple levels of Group layers :D

Use

LayerAccessor::enumerate_layers(map: &tiled::Map) -> Vec<(Layer, LayerKey)>

and

LayerAccessor::get_layer<'map>(map: &'map tiled::Map, key: LayerKey) -> Option<Layer<'map>>

to enumerate and retrieve Layers, respectively.

/// A path to a Layer in the layer tree: a sequence of indexes
/// at each respective layer.
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum LayerKey {
    Inline {
        length: u8,
        indexes: [usize; MAX_KEY_LEN]
    },
    Vec(Vec<usize>)
}

impl LayerKey {
    pub fn new(first_index: usize) -> Self {
        Self::Inline { length: 1, indexes: [first_index, 0, 0, 0] }
    }

    pub fn len(&self) -> usize {
        match self {
            LayerKey::Inline { length, .. } => *length as usize,
            LayerKey::Vec(v) => v.len(),
        }
    }

    /// Returns: Iterator to iterate indexes in the path represented by the key.
    pub fn iter(&self) -> LayerKeyIter {
        LayerKeyIter::new(self.clone())
    }

    pub fn append(&self, next_index: usize) -> Self {
        assert_eq!(MAX_KEY_LEN, 4);
        match self {
            LayerKey::Inline { length: 4, indexes } =>
                LayerKey::Vec(vec![
                    indexes[0],
                    indexes[1],
                    indexes[2],
                    indexes[3],
                    next_index,
                ]),

            LayerKey::Inline { length, indexes } => {
                let mut new_indexes = indexes.clone();
                new_indexes[*length as usize] = next_index;

                LayerKey::Inline {
                    length: length+1,
                    indexes: new_indexes,
                }
            },

            LayerKey::Vec(v) => {
                let mut new_vec = v.clone();
                new_vec.push(next_index);
                LayerKey::Vec(new_vec)
            }
        }
    }
}

impl Add<usize> for LayerKey {
    type Output = Self;

    fn add(self, rhs: usize) -> Self {
        self.append(rhs)
    }
}

pub struct LayerKeyIter {
    key: LayerKey,
    index: usize,
}

impl LayerKeyIter {
    pub fn new(key: LayerKey) -> Self {
        Self { key, index: 0 }
    }

    pub fn first(&mut self) -> usize {
        // SAFETY: LayerKey is never empty, so first item always exists.
        assert_eq!(self.index, 0);
        self.next().unwrap()
    }
}

impl Iterator for LayerKeyIter {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        match &self.key {
            LayerKey::Inline { length, indexes } => {
                if *length as usize == self.index {
                    None
                } else {
                    self.index += 1;
                    Some(indexes[self.index-1])
                }
            }
            LayerKey::Vec(v) => {
                self.index += 1;
                v.get(self.index - 1)
                    .cloned()
            }
        }
    }
}

pub struct LayerAccessor {}

impl LayerAccessor {

    // impl Iterator<Item = Layer<'_>>
    /// Enumerate all layers in the map, recursively.
    pub fn enumerate_layers(map: &tiled::Map) -> Vec<(Layer, LayerKey)> {
        let mut result: Vec<(Layer, LayerKey)> = map
            .layers()
            .enumerate()
            .map(|(i, layer)| (layer, LayerKey::new(i)))
            .collect();

        let mut index = 0;
        while index < result.len() {
            let (layer, key) = result[index].clone();
            if let LayerType::Group(group_layer) = layer.layer_type() {
                for (i, inner_layer) in group_layer.layers().enumerate() {
                    // depth first - this is the order Tiled draws them in.
                    result.insert(index + 1,(inner_layer, key.clone() + i));
                    // this messes up the rendering:
                    // result.push((inner_layer, key.clone() + i));
                }
            }
            index += 1
        }

        result
    }

    pub fn get_layer<'map>(map: &'map tiled::Map, key: LayerKey) -> Option<Layer<'map>> {
        let mut it = key.iter();
        let index = it.first();
        let mut result = map.get_layer(index);

        for index in it {
            let Some(layer) = result else {
                return None
            };

            if let LayerType::Group(group_layer) = &layer.layer_type() {
                let Some(local_layer) = group_layer.get_layer(index).clone() else {
                    return None
                };
                let unsafe_layer = unsafe {
                    // Hack for https://github.com/mapeditor/rs-tiled/pull/307 - until it's released
                    mem::transmute::<Layer<'_>, Layer<'map>>(local_layer)
                };
                result = Some(unsafe_layer);
            } else {
                return None
            }
        }

        result
    }
}

Hereby granting the permission to anyone to use it in any way you like.