deno_webgpu 0.169.0

WebGPU implementation for Deno
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// Copyright 2018-2025 the Deno authors. MIT license.

use deno_core::op2;
use deno_core::webidl::WebIdlInterfaceConverter;
use deno_core::GarbageCollected;
use deno_core::WebIDL;

use crate::Instance;

pub struct GPUSampler {
  pub instance: Instance,
  pub id: wgpu_core::id::SamplerId,
  pub label: String,
}

impl Drop for GPUSampler {
  fn drop(&mut self) {
    self.instance.sampler_drop(self.id);
  }
}

impl WebIdlInterfaceConverter for GPUSampler {
  const NAME: &'static str = "GPUSampler";
}

impl GarbageCollected for GPUSampler {}

#[op2]
impl GPUSampler {
  #[getter]
  #[string]
  fn label(&self) -> String {
    self.label.clone()
  }
  #[setter]
  #[string]
  fn label(&self, #[webidl] _label: String) {
    // TODO(@crowlKats): no-op, needs wpgu to implement changing the label
  }
}

#[derive(WebIDL)]
#[webidl(dictionary)]
pub(super) struct GPUSamplerDescriptor {
  #[webidl(default = String::new())]
  pub label: String,

  #[webidl(default = GPUAddressMode::ClampToEdge)]
  pub address_mode_u: GPUAddressMode,
  #[webidl(default = GPUAddressMode::ClampToEdge)]
  pub address_mode_v: GPUAddressMode,
  #[webidl(default = GPUAddressMode::ClampToEdge)]
  pub address_mode_w: GPUAddressMode,
  #[webidl(default = GPUFilterMode::Nearest)]
  pub mag_filter: GPUFilterMode,
  #[webidl(default = GPUFilterMode::Nearest)]
  pub min_filter: GPUFilterMode,
  #[webidl(default = GPUFilterMode::Nearest)]
  pub mipmap_filter: GPUFilterMode,

  #[webidl(default = 0.0)]
  pub lod_min_clamp: f32,
  #[webidl(default = 32.0)]
  pub lod_max_clamp: f32,

  pub compare: Option<GPUCompareFunction>,

  #[webidl(default = 1)]
  #[options(clamp = true)]
  pub max_anisotropy: u16,
}

#[derive(WebIDL)]
#[webidl(enum)]
pub(crate) enum GPUAddressMode {
  ClampToEdge,
  Repeat,
  MirrorRepeat,
}

impl From<GPUAddressMode> for wgpu_types::AddressMode {
  fn from(value: GPUAddressMode) -> Self {
    match value {
      GPUAddressMode::ClampToEdge => Self::ClampToEdge,
      GPUAddressMode::Repeat => Self::Repeat,
      GPUAddressMode::MirrorRepeat => Self::MirrorRepeat,
    }
  }
}

// Same as GPUMipmapFilterMode
#[derive(WebIDL)]
#[webidl(enum)]
pub(crate) enum GPUFilterMode {
  Nearest,
  Linear,
}

impl From<GPUFilterMode> for wgpu_types::FilterMode {
  fn from(value: GPUFilterMode) -> Self {
    match value {
      GPUFilterMode::Nearest => Self::Nearest,
      GPUFilterMode::Linear => Self::Linear,
    }
  }
}

#[derive(WebIDL)]
#[webidl(enum)]
pub(crate) enum GPUCompareFunction {
  Never,
  Less,
  Equal,
  LessEqual,
  Greater,
  NotEqual,
  GreaterEqual,
  Always,
}

impl From<GPUCompareFunction> for wgpu_types::CompareFunction {
  fn from(value: GPUCompareFunction) -> Self {
    match value {
      GPUCompareFunction::Never => Self::Never,
      GPUCompareFunction::Less => Self::Less,
      GPUCompareFunction::Equal => Self::Equal,
      GPUCompareFunction::LessEqual => Self::LessEqual,
      GPUCompareFunction::Greater => Self::Greater,
      GPUCompareFunction::NotEqual => Self::NotEqual,
      GPUCompareFunction::GreaterEqual => Self::GreaterEqual,
      GPUCompareFunction::Always => Self::Always,
    }
  }
}