zaplib 0.0.3

⚡ Zaplib is a fast, cross-platform (web+native), GPU-based application framework, written in Rust.
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
116
117
118
119

//! Managing GPU textures.

use crate::*;

/// A persistent reference to a GPU texture.
///
/// TODO(JP): The way this works is a bit inconsistent with other draw tree structures, like
/// [`View`], [`Area`], and so on. These never get reused. It might be nicer to allocate these
/// dynamically and clean them up if they don't get used in a draw tree.
#[derive(Debug, Default)]
pub struct Texture {
    pub(crate) handle: Option<TextureHandle>,
}

impl Texture {
    pub fn get_color(&mut self, cx: &mut Cx) -> TextureHandle {
        if let Some(handle) = self.handle {
            handle
        } else {
            let handle = TextureHandle {
                texture_id: {
                    cx.textures.push(CxTexture::default());
                    (cx.textures.len() - 1) as u32
                },
            };
            self.handle = Some(handle);
            handle
        }
    }

    pub fn get_depth(&mut self, cx: &mut Cx) -> TextureHandle {
        if let Some(handle) = self.handle {
            handle
        } else {
            let handle = TextureHandle {
                texture_id: {
                    cx.textures.push(CxTexture {
                        desc: TextureDesc { format: TextureFormat::Depth32Stencil8, ..TextureDesc::default() },
                        ..CxTexture::default()
                    });
                    (cx.textures.len() - 1) as u32
                },
            };
            self.handle = Some(handle);
            handle
        }
    }

    pub fn get_with_dimensions(&mut self, cx: &mut Cx, width: usize, height: usize) -> TextureHandle {
        if let Some(handle) = self.handle {
            handle
        } else {
            let handle = TextureHandle {
                texture_id: {
                    let cx_texture = CxTexture {
                        desc: TextureDesc { width: Some(width), height: Some(height), ..Default::default() },
                        image_u32: vec![0; width * height],
                        ..CxTexture::default()
                    };
                    cx.textures.push(cx_texture);
                    (cx.textures.len() - 1) as u32
                },
            };
            self.handle = Some(handle);
            handle
        }
    }

    pub fn unwrap_texture_handle(&self) -> TextureHandle {
        self.handle.unwrap()
    }
}

/// A pointer to a [`CxTexture`] (indexed in [`Cx::textures`] using [`TextureHandle::texture_id`]),
#[derive(Copy, Clone, PartialEq, Debug)]
pub struct TextureHandle {
    pub(crate) texture_id: u32,
}

impl TextureHandle {
    pub fn get_image_mut<'a>(&self, cx: &'a mut Cx) -> &'a mut [u32] {
        let cx_texture = cx.textures.get_mut(self.texture_id as usize).unwrap();
        cx_texture.update_image = true;
        &mut cx_texture.image_u32
    }
}

// TODO(Paras): Standardize and test all platforms on RGBA.
// TODO(Paras): Make image_u32 updating work on Linux.
#[derive(Copy, Clone, PartialEq)]
pub(crate) enum TextureFormat {
    ImageRGBA,
    Depth32Stencil8,
}

#[derive(Clone, PartialEq)]
pub(crate) struct TextureDesc {
    pub(crate) format: TextureFormat,
    pub(crate) width: Option<usize>,
    pub(crate) height: Option<usize>,
    pub(crate) multisample: Option<usize>,
}

impl Default for TextureDesc {
    fn default() -> Self {
        TextureDesc { format: TextureFormat::ImageRGBA, width: None, height: None, multisample: None }
    }
}

/// Texture data, which you can render as an image in your shaders. See e.g. [`crate::ImageIns`].
#[derive(Default)]
pub(crate) struct CxTexture {
    pub(crate) desc: TextureDesc,
    pub(crate) image_u32: Vec<u32>,
    pub(crate) update_image: bool,
    // Not used on wasm
    #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
    pub(crate) platform: CxPlatformTexture,
}