How to render a shader outline for a 2d mesh?

[tirithen]

I have a 2d project where I want to render island meshes, with a repeated texture, and a black outline at the edge of the island.

I got the repeated texture to work some time ago, but I have not been able to figure out how to render the black outline at the edge of the island mesh.

After searching on the internet I have found shader examples where alpha value sampling of the surrounding pixels are used:

from bevy-simple-outline

However as I want to render the outline for a 2d mesh using a repeated texture (see repeated texture setup here) rather than detecting the edges from the transparent pixels within a sprite I suspect that I need some other method for generating the outline. Possibly with several render passes as I have seen done for 3d outline shaders?

Are there any examples of how to do this? I'm learning, but still fairly new to the Bevy render pipeline and shaders.

I have this:

I want a result similar to this (edited in GIMP):

My current 2d mesh builder code in case that is helpful:

use bevy::{
    prelude::*,
    render::{mesh::Indices, render_resource::PrimitiveTopology},
};
use bevy_prototype_lyon::prelude::FillOptions;
use lyon::{
    lyon_tessellation::{geometry_builder::simple_builder, FillTessellator, VertexBuffers},
    math::Point,
    path::Path,
};

fn build_mesh(buffers: &VertexBuffers<Point, u16>) -> Mesh {
    let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);

    let positions = buffers
        .vertices
        .iter()
        .map(|v| [v.x, v.y, 0.0])
        .collect::<Vec<[f32; 3]>>();
    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);

    let normals = buffers
        .vertices
        .iter()
        .map(|_| [0.0, 0.0, 1.0])
        .collect::<Vec<[f32; 3]>>();
    mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, normals);

    let uvs = buffers
        .vertices
        .iter()
        .map(|v| [v.x, v.y])
        .collect::<Vec<[f32; 2]>>();
    mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, uvs);

    let mut indices = buffers.indices.clone();
    indices.reverse();
    mesh.set_indices(Some(Indices::U32(
        indices.iter().map(|i| *i as u32).collect(),
    )));

    mesh
}

pub fn mesh_from_path(path: Path) -> Mesh {
    let mut buffers: VertexBuffers<Point, u16> = VertexBuffers::new();

    let mut vertex_builder = simple_builder(&mut buffers);
    let mut tessellator = FillTessellator::new();
    let result = tessellator.tessellate_path(&path, &FillOptions::default(), &mut vertex_builder);
    assert!(result.is_ok());

    build_mesh(&buffers)
}