nvgx 0.3.3

Pure-rust implementation of NanoVG
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

use super::{Context, ImageFlags, ImageId, TextureType};
use crate::RendererDevice;

impl<R: RendererDevice> Context<R> {
    pub fn create_image_init<D: AsRef<[u8]>>(
        &mut self,
        flags: ImageFlags,
        data: D,
    ) -> anyhow::Result<ImageId> {
        let img = image::load_from_memory(data.as_ref())?;
        let img = img.to_rgba8();
        let dimensions = img.dimensions();
        let img = self.renderer.create_texture(
            TextureType::RGBA,
            dimensions.0,
            dimensions.1,
            flags,
            Some(&img.into_raw()),
        )?;
        Ok(img)
    }

    pub fn create_image_from_file<P: AsRef<std::path::Path>>(
        &mut self,
        flags: ImageFlags,
        path: P,
    ) -> anyhow::Result<ImageId> {
        self.create_image_init(flags, std::fs::read(path)?)
    }

    pub fn create_image(
        &mut self,
        width: u32,
        height: u32,
        fmt: TextureType,
        flags: ImageFlags,
        data: Option<&[u8]>,
    ) -> anyhow::Result<ImageId> {
        let img = self
            .renderer
            .create_texture(fmt, width, height, flags, data)?;
        Ok(img)
    }

    /// area: Some(x, y, w, h)
    pub fn update_image(
        &mut self,
        img: ImageId,
        data: &[u8],
        area: Option<(u32, u32, u32, u32)>,
    ) -> anyhow::Result<()> {
        let (x, y, w, h) = if let Some(area) = area {
            area
        } else {
            let (w, h) = self.image_size(img.clone())?;
            (0, 0, w, h)
        };
        self.renderer.update_texture(img, x, y, w, h, data)?;
        Ok(())
    }

    pub fn image_size(&self, img: ImageId) -> anyhow::Result<(u32, u32)> {
        let res = self.renderer.texture_size(img)?;
        Ok(res)
    }

    pub fn delete_image(&mut self, img: ImageId) -> anyhow::Result<()> {
        self.renderer.delete_texture(img)?;
        Ok(())
    }
}