mepeyew 0.3.5

mepeyew - Small But Powerful 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

use super::*;

impl WebGpuContext {
    pub fn new_attachment_image(
        &mut self,
        initial_width: usize,
        initial_height: usize,
        attachment_usage: AttachmentImageUsage,
        ext: Option<NewAttachmentImageExt>,
    ) -> GResult<AttachmentImageId> {
        let attachment_image = WebGpuAttachmentImage::new(
            &self.device,
            initial_width,
            initial_height,
            attachment_usage,
            ext,
        );
        self.attachment_images.push(attachment_image);

        Ok(AttachmentImageId::from_id(self.attachment_images.len() - 1))
    }
}

pub struct WebGpuAttachmentImage {
    attachment_usage: AttachmentImageUsage,
    ext: NewAttachmentImageExt,

    texture: GpuTexture,
    pub texture_view: GpuTextureView,
    pub format: GpuTextureFormat,
}

impl WebGpuAttachmentImage {
    pub fn new(
        device: &GpuDevice,
        initial_width: usize,
        initial_height: usize,
        attachment_usage: AttachmentImageUsage,
        ext: Option<NewAttachmentImageExt>,
    ) -> Self {
        let ext = ext.unwrap_or_default();

        let format = match attachment_usage {
            AttachmentImageUsage::ColorAttachment => ext
                .color_format
                .map(|color_format| match color_format {
                    AttachmentImageColorFormat::R8UNorm => GpuTextureFormat::R8unorm,
                    AttachmentImageColorFormat::R8G8UNorm => GpuTextureFormat::Rg8unorm,
                    AttachmentImageColorFormat::R8G8B8A8UNorm => GpuTextureFormat::Rgba8snorm,
                    AttachmentImageColorFormat::R32SFloat => GpuTextureFormat::R32float,
                    AttachmentImageColorFormat::R32G32SFloat => GpuTextureFormat::Rg32float,
                    AttachmentImageColorFormat::R32G32B32A32SFloat => GpuTextureFormat::Rgba32float,
                })
                .unwrap_or(WEBGPU_COLOR_ATTACHMENT_FORMAT),
            AttachmentImageUsage::DepthAttachment => WEBGPU_DEPTH_ATTACHMENT_FORMAT,
        };

        let size = Array::new();
        size.push(&JsValue::from(initial_width));
        size.push(&JsValue::from(initial_height));

        let usage = GpuTextureUsageFlags::RenderAttachment as u32
            | GpuTextureUsageFlags::TextureBinding as u32;

        let mut texture_info = GpuTextureDescriptor::new(format, &size, usage);
        texture_info.sample_count(match ext.msaa_samples.unwrap_or_default() {
            MsaaSampleCount::Sample1 => 1,
            MsaaSampleCount::Sample2 => 2,
            MsaaSampleCount::Sample4 => 4,
            MsaaSampleCount::Sample8 => 8,
            MsaaSampleCount::Sample16 => 16,
            MsaaSampleCount::Sample32 => 32,
            MsaaSampleCount::Sample64 => 64,
        });

        let texture = device.create_texture(&texture_info);
        let texture_view = texture.create_view();

        WebGpuAttachmentImage {
            ext,
            attachment_usage,
            texture,
            texture_view,
            format,
        }
    }

    pub fn recreate_with_new_size(&mut self, device: &GpuDevice, width: usize, height: usize) {
        self.texture.destroy();
        let new_attachment_image = WebGpuAttachmentImage::new(
            device,
            width,
            height,
            self.attachment_usage,
            Some(self.ext.clone()),
        );
        *self = new_attachment_image;
    }
}