wasdk-wgpu 0.1.0

A wgpu backend over wasi:webgpu, so a program written against wgpu draws in a component unchanged.
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

//! Shader modules, from WGSL text only.

use std::pin::Pin;
use std::sync::Arc;

use wasdk::webgpu::{GpuDevice, GpuShaderModule, GpuShaderModuleDescriptor};
use wgpu::custom::{DispatchShaderModule, ShaderCompilationInfoFuture, ShaderModuleInterface};

use crate::convert;
use crate::gap::wasi_gap;

#[derive(Debug)]
pub struct WasdkShaderModule {
    module: Arc<GpuShaderModule>,
}

downcast!(WasdkShaderModule: api wgpu::ShaderModule);

impl WasdkShaderModule {
    pub(crate) fn gpu_shader_module(&self) -> &GpuShaderModule {
        &self.module
    }
}

pub(crate) fn create_shader_module(
    device: &GpuDevice,
    desc: &wgpu::ShaderModuleDescriptor<'_>,
) -> DispatchShaderModule {
    match &desc.source {
        wgpu::ShaderSource::Wgsl(code) => compile(device, code, desc.label),
        // `ShaderSource` is `#[non_exhaustive]`; SPIR-V, GLSL and naga IR sit behind wgpu
        // features and have no wasi form either way.
        _ => wasi_gap("shader sources other than WGSL (ShaderSource::{SpirV, Glsl, Naga})"),
    }
}

pub(crate) fn create_shader_module_passthrough(
    device: &GpuDevice,
    desc: &wgpu::ShaderModuleDescriptorPassthrough<'_>,
) -> DispatchShaderModule {
    match &desc.wgsl {
        Some(code) => compile(device, code, desc.label),
        None => wasi_gap("passthrough shaders in a language other than WGSL"),
    }
}

fn compile(device: &GpuDevice, code: &str, label: wgpu::Label<'_>) -> DispatchShaderModule {
    let descriptor = GpuShaderModuleDescriptor {
        code: code.to_owned(),
        compilation_hints: None,
        label: convert::label(label),
    };
    DispatchShaderModule::custom(WasdkShaderModule {
        module: Arc::new(device.create_shader_module(&descriptor)),
    })
}

impl ShaderModuleInterface for WasdkShaderModule {
    fn get_compilation_info(&self) -> Pin<Box<dyn ShaderCompilationInfoFuture>> {
        let module = Arc::clone(&self.module);
        Box::pin(async move {
            convert::compilation_info_from_wasi(&module.get_compilation_info().await)
        })
    }
}