1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use fontdue::Font;
use image::{GenericImage, GenericImageView, RgbaImage};
use spitfire_draw::{context::DrawContext, utils::Vertex};
use spitfire_glow::{graphics::Graphics, renderer::GlowTextureFormat};
use std::{borrow::Cow, path::Path};

pub fn load_shader(
    draw: &mut DrawContext,
    graphics: &Graphics<Vertex>,
    name: impl Into<Cow<'static, str>>,
    vertex: &str,
    fragment: &str,
) {
    draw.shaders
        .insert(name.into(), graphics.shader(vertex, fragment).unwrap());
}

pub fn load_shaders<const N: usize>(
    draw: &mut DrawContext,
    graphics: &Graphics<Vertex>,
    // [id, vertex, fragment]
    items: [(&'static str, &str, &str); N],
) {
    for (name, vertex, fragment) in items {
        load_shader(draw, graphics, name, vertex, fragment);
    }
}

pub fn load_texture(
    draw: &mut DrawContext,
    graphics: &Graphics<Vertex>,
    name: impl Into<Cow<'static, str>>,
    path: impl AsRef<Path>,
    pages: u32,
    pages_in_columns: bool,
) {
    let path = path.as_ref();
    let mut image = image::open(path)
        .unwrap_or_else(|_| panic!("Failed to load texture: {:?}", path))
        .into_rgba8();
    image = if pages > 1 {
        if pages_in_columns {
            let width = image.width() / pages;
            let height = image.height();
            let mut result = RgbaImage::new(width, height * pages);
            for index in 0..pages {
                let view = image.view(index * width, 0, width, height);
                result.copy_from(&*view, 0, index * height).unwrap();
            }
            result
        } else {
            image
        }
    } else {
        image
    };
    draw.textures.insert(
        name.into(),
        graphics
            .texture(
                image.width(),
                image.height() / pages,
                pages,
                GlowTextureFormat::Rgba,
                image.as_raw(),
            )
            .unwrap(),
    );
}

pub fn load_textures<const N: usize>(
    draw: &mut DrawContext,
    graphics: &Graphics<Vertex>,
    // [id, path, pages count]
    items: [(&'static str, &str, u32, bool); N],
) {
    for (name, path, pages, pages_in_columns) in items {
        load_texture(draw, graphics, name, path, pages, pages_in_columns);
    }
}

pub fn load_font(
    draw: &mut DrawContext,
    name: impl Into<Cow<'static, str>>,
    path: impl AsRef<Path>,
) {
    let path = path.as_ref();
    let bytes = std::fs::read(path).unwrap_or_else(|_| panic!("Failed to load font: {:?}", path));
    draw.fonts
        .insert(name, Font::from_bytes(bytes, Default::default()).unwrap());
}

pub fn load_fonts<const N: usize>(
    draw: &mut DrawContext,
    // [id, path]
    items: [(&'static str, &str); N],
) {
    for (name, path) in items {
        load_font(draw, name, path);
    }
}