mugl 0.1.2

Minimalistic Low-level WebGL 2.0 / WebGPU 3D graphics abstraction layer for Rust and WebAssembly
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

use async_trait::async_trait;
use mugl::prelude::*;

use crate::common::{App, ColorVertex, TRIANGLE};

#[derive(Debug)]
pub struct BasicExample {
    device: Device,
    pipeline: RenderPipeline,
    pass: RenderPass,
    buffer: Buffer,
}

#[async_trait(?Send)]
impl App for BasicExample {
    fn new(device: Device, _size: mugl::Extent2D) -> Self {
        let vertices = bytemuck::cast_slice(TRIANGLE);
        let buffer = device.create_buffer(BufferDescriptor {
            usage: BufferUsage::VERTEX,
            size: vertices.len() as BufferSize,
        });
        device.write_buffer(&buffer, 0, vertices);

        cfg_if::cfg_if! {
            if #[cfg(feature = "backend-wgpu")] {
                let vertex = &device.create_shader(ShaderDescriptor {
                    usage: ShaderStage::VERTEX | ShaderStage::FRAGMENT,
                    code: include_str!("../shader/basic.wgsl").into(),
                });
                let fragment = vertex;
            } else {
                let vertex = &device.create_shader(ShaderDescriptor {
                    usage: ShaderStage::VERTEX,
                    code: include_str!("../shader/basic.vs.glsl").into(),
                });
                let fragment = &device.create_shader(ShaderDescriptor {
                    usage: ShaderStage::FRAGMENT,
                    code: include_str!("../shader/basic.fs.glsl").into(),
                });
            }
        }

        let pipeline = device.create_render_pipeline(RenderPipelineDescriptor {
            vertex,
            fragment,
            buffers: &[VertexBufferLayout {
                stride: core::mem::size_of::<ColorVertex>() as BufferSize,
                step_mode: VertexStepMode::Vertex,
                attributes: &[
                    VertexAttribute {
                        offset: 0,
                        shader_location: 0,
                        format: VertexFormat::F32x3,
                    },
                    VertexAttribute {
                        offset: core::mem::size_of::<[f32; 3]>() as BufferSize,
                        shader_location: 1,
                        format: VertexFormat::F32x4,
                    },
                ],
            }],
            bind_groups: &[],
            targets: Default::default(),
            primitive: Default::default(),
            depth_stencil: Default::default(),
            multisample: Default::default(),
        });

        let pass = device.create_render_pass(RenderPassDescriptor::Default {
            clear_color: Some(Color(0.1, 0.2, 0.3, 1.0)),
            clear_depth: None,
            clear_stencil: None,
        });

        Self {
            device,
            pipeline,
            pass,
            buffer,
        }
    }

    fn device(&self) -> &Device {
        &self.device
    }

    fn render(&mut self, _t: f64) -> bool {
        {
            let encoder = self.device.render(&self.pass);
            encoder.pipeline(&self.pipeline);
            encoder.vertex(0, &self.buffer, 0);
            encoder.draw(0..3, 0..1);
            encoder.submit();
        }
        self.device.present();
        false
    }
}