$ ghq get https://github.com/Chlumsky/msdf-atlas-gen
$ cd ~/ghq/github.com/Chlumsky/msdf-atlas-gen
$ mkdir build && cd build
$ cmake ../ && make
$ # cp bin/msdf-atlas-gen /path/to/a/directory/in/your/PATH

# 日本語文字コード: https://stackoverflow.com/a/53807563

# ASCII
[0x0000, 0x007E]

# Hiragana
[0x3041,0x3096]

# Katakana
[0x30A0,0x30FF]

# Kanji
[0x3400,0x4DB5]
[0x4E00,0x9FCB]
[0xF900,0xFA6A]

# Japanese Symbols and Punctuation
[0x3000,0x303F]

#!/usr/bin/env bash -euE

size=16
px_range=2

ttf="$1"
charset="$2"

tmp="$(mktemp)"
cat "$charset" | grep -v '#' | grep -v '^$' | tr '\n' ',' > "$tmp"

dir="$(dirname "$ttf")"
name="$(basename "$ttf" .ttf)"

msdf-atlas-gen \
    -size "$size" \
    -pxrange "$px_range" \
    -charset "$tmp" \
    -font "$ttf" \
    -json "$dir/$name-meta.json" \
    -imageout "$dir/$name-texture.png"

[profile.dev.package."image"]
opt-level = 3

[profile.dev.package."ttf-parser"]
opt-level = 3

    let color = textureSample(shadow_texture, shadow_sampler, uv);

    var a: f32; // 周囲のセルのアルファ値を合成していく
    // ~~~~

-    return vec4<f32>(color.rgb, a);
+    return vec4<f32>(color.rgb, max(a, color.a));

// フォントアトラスの四辺形に文字 (glyph) を焼く
let dst_aabr = /* ~~ */

let glyph_size = wgpu::Extent3d {
    width: dst_aabr.size().w as u32,
    height: dst_aabr.size().h as u32,
    depth_or_array_layers: 1,
};

let n_channels = 1;

// グリフのピクセルデータを説明する型
let data_layout = wgpu::ImageDataLayout {
    offset: 0,
    bytes_per_row: std::num::NonZeroU32::new(n_channels as u32 * glyph_size.width),
    rows_per_image: None,
};

// 書き込み先 (フォントアトラス) のオフセットを設定する
let mut target = self.img.texture.as_image_copy();
target.origin.x = dst_aabr.min.x as u32;
target.origin.y = dst_aabr.min.y as u32;

queue.write_texture(target, &glyph.pixels, data_layout, glyph_size);

/// (Internal) Resource for implicit root node
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct RootNode {
    entity: Entity,
}

/// Component with child/parent relationship
#[derive(Component, Debug, Clone, Default, PartialEq, Eq, Hash)]
pub struct Node {
    pub as_parent: AsParent,
    pub as_child: Option<AsChild>,
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
pub struct AsParent {
    pub(crate) n_children: u32,
    pub(crate) first_child: Option<Entity>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AsChild {
    pub(crate) parent: Entity,
    pub(crate) next: Option<Entity>,
    pub(crate) prev: Option<Entity>,
}

pub fn update_transform_system(
    root: Res<RootNode>,
    node: Comp<Node>,
    (local, mut global): (Comp<LocalTransform2d>, CompMut<GlobalTransform2d>),
) {
    let is_dirty = false;
    let root_mat = Mat3::identity();
    node.child_entities(root.entity()).for_each(|entity| {
        self::update_transform_rec(is_dirty, entity, root_mat, &node, (&local, &mut global));
    });
}

macro_rules! unwrap {
    ($x:expr) => {
        match $x {
            Some(x) => x,
            None => return,
        }
    };
}

/// DFS (depth-first search)
fn update_transform_rec(
    mut is_dirty: bool,
    entity: Entity,
    mut mat: Mat3<f32>,
    node: &Comp<Node>,
    (local, global): (&Comp<LocalTransform2d>, &mut CompMut<GlobalTransform2d>),
) {
    {
        let local = unwrap!(local.get(entity));
        let global = unwrap!(global.get_mut(entity));

        is_dirty |= local.is_dirty;

        if is_dirty {
            mat = mat * local.mat;
            global.mat = mat;
        }
    }

    node.child_entities(entity).for_each(|entity| {
        update_transform_rec(is_dirty, entity, mat, node, (local, global));
    });
}

#[derive(GatBorrowWorld, Debug)]
pub struct TextRender<'w> {
    fonts: ResMut<'w, text::FontArena>,
    baker: ResMut<'w, text::RasterGlyphBaker>,
    buf: ResMut<'w, RasterFontRenderBuffer>,
}

fn test_raster_render(
    mut draw: Draw,
    mut fonts: ResMut<res::GameFonts>,
    mut text_render: TextRender,
) {
    // extracted text
    let h = 24;
    let text = "ぼくはかわくぼ";
    let offset = Vec2::new(100.0, 400.0);
    let font_ix = fonts.mp1;

    text_render.draw_sized(&mut draw, text, font_ix, h, offset);
}

/// API for handling hierarchy of entities under the [`RootNode`](tfm::RootNode)
#[derive(GatBorrowWorld, Debug)]
pub struct HieMut<'w> {
    root: Res<'w, tfm::RootNode>,
    node: CompMut<'w, tfm::Node>,
}

impl<'w> HieMut<'w> {
    pub fn add_child(&mut self, parent: Entity, child: Entity) {
        self.node.add_child(parent, child);
    }

    pub fn print(&self) {
        tfm_system::print_ui_rec(0, self.root.entity(), &self.node);
    }
}

let mut hie = world.borrow::<ui::HieMut>();
hie.add_child(root, ent);
hie.add_child(ent, ent2);

/// (Component) Retained-mode rendering text
#[derive(Component, Debug, Clone, PartialEq)]
pub struct Text {
    pub s: String,
    pub style: RasterGlyphStyle,
    pub origin: Vec2<f32>,
}

/// (Component) Rasterized [`Text`]
#[derive(Component, Debug, Clone, PartialEq)]
pub struct RasterizedText {
    pub is_dirty: bool,
    pub tex_quads: TexQuads,
    /// The whole size after rasterization
    pub size: Extent2<f32>,
}

#[apply(script!)]
pub async fn example1(mut world: CosyncInput<World>) { /* ~~ */ }

#[apply(script!)]
pub async fn example2(mut world: CosyncInput<World>) { /* ~~ */ }

type F = fn(CosyncInput<World>) -> Pin<Box<dyn Future<Output = ()> + Send>>;
let mut xs: Vec<F> = Vec::new();
xs.push(example1);
xs.push(example2);

#[macro_export]
macro_rules! script {(
    $( #[$attr:meta] )*
    $pub:vis
    async
    fn $fname:ident ( $($args:tt)* ) $(-> $Ret:ty)?
    {
        $($body:tt)*
    }
) => (
    $( #[$attr] )*
    #[allow(unused_parens)]
    $pub
    fn $fname ( $($args)* ) -> ::std::pin::Pin<::std::boxed::Box<
        dyn 'static + Send + ::std::future::Future<Output = ($($Ret)?)>
    >>
    {
        Box::pin(async move { $($body)* })
    }
)}