picodraw 0.2.0

A smol gpu graphics library
Documentation 
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::{graph::ShaderGraph, types::GlType, Bounds, Float2, Float4, Shader, ShaderContext};
use encoding::{InputStructure, BUILTIN_BOUNDS, BUILTIN_POSITION, BUILTIN_RESOLUTION};
use rustc_hash::FxHashMap;
use std::any::{type_name, TypeId};

mod atlas;
mod encoding;
mod glsl;

pub use atlas::TextureAtlas;
pub use encoding::QuadEncoder;
pub use glsl::VERTEX_SHADER;

struct ShaderData {
    id: u32,
    graph: ShaderGraph<Float4>,
    input: InputStructure,
}

pub struct ShaderMap {
    shaders: FxHashMap<TypeId, ShaderData>,
    dirty: bool,
}

impl ShaderMap {
    pub fn new() -> Self {
        Self {
            shaders: FxHashMap::default(),
            dirty: false,
        }
    }

    pub fn register<T: Shader>(&mut self) {
        let id = T::id();
        if self.shaders.contains_key(&id) {
            return;
        }

        let mut input = None;
        let graph = ShaderGraph::collect(|| {
            let (structure, vars) = InputStructure::of::<T>();
            input = Some(structure);
            T::draw(ShaderContext {
                vars: &vars,
                position: Float2::input_raw(BUILTIN_POSITION),
                resolution: Float2::input_raw(BUILTIN_RESOLUTION),
                bounds: Float4::input_raw(BUILTIN_BOUNDS),
            })
        });

        self.dirty = true;
        self.shaders.insert(
            id,
            ShaderData {
                id: self.shaders.len() as u32,
                graph,
                input: input.unwrap(),
            },
        );
    }

    pub fn is_dirty(&self) -> bool {
        self.dirty
    }

    pub fn recompile(&mut self, max_texture_size: u32) -> (String, TextureAtlas) {
        self.dirty = false;

        let atlas = TextureAtlas::pack(
            self.shaders.values().flat_map(|data| {
                data.input
                    .textures
                    .iter()
                    .enumerate()
                    .map(move |(id, generator)| (data.id, id as u32, generator()))
            }),
            max_texture_size,
        );

        let fragment_src = glsl::generate_fragment_shader(
            self.shaders
                .values()
                .map(|data| (data.id, &data.graph, &data.input)),
            &atlas,
        );

        (fragment_src, atlas)
    }

    pub fn write<T: Shader>(
        &mut self,
        encoder: &mut QuadEncoder,
        bounds: Bounds,
        value: &T,
        width: u32,
        height: u32,
    ) {
        let data = self.shaders.get(&T::id()).unwrap_or_else(|| {
            if cfg!(debug_assertions) {
                panic!("register the drawable first ({})", type_name::<T>())
            } else {
                panic!("register the drawable first")
            }
        });

        encoder.push(
            value,
            data.id,
            bounds,
            &data.input,
            width as f32,
            height as f32,
        );
    }
}