1pub mod backend;
9mod buffer;
10mod bundle;
11pub mod canvas;
12mod compute;
13mod query;
14mod readback;
15#[cfg(test)]
16mod tests;
17mod texture;
18
19use backend::{Adapter, Client};
20use core::ffi::c_void;
21use redjs::webapi::util::*;
22use redjs::{capi, glue};
23use std::collections::{HashMap, VecDeque};
24use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
25use std::sync::{Arc, Mutex, OnceLock};
26
27pub fn register() {
29 redjs::webapi::gpu_ext::register(&Extension);
30}
31
32struct Extension;
33impl redjs::webapi::gpu_ext::GpuExtension for Extension {
34 unsafe fn install(&self, g: *mut c_void) {
35 install(g);
36 }
37 fn forget(&self, gone: redjs::context::Gone) {
38 forget(gone);
39 }
40 unsafe fn pump(&self, g: *mut c_void) {
41 canvas::pump(g);
42 }
43 unsafe fn create_context(&self, g: *mut c_void, owner: u64, w: u32, h: u32) -> u64 {
44 canvas::create(g, owner, w, h, None)
45 }
46 unsafe fn resize(&self, g: *mut c_void, ctx: u64, w: u32, h: u32) {
47 let _ = canvas::resize(g, ctx, w, h);
48 }
49 unsafe fn is_context(&self, g: *mut c_void, v: u64) -> bool {
50 canvas::is_context(g, v)
51 }
52 unsafe fn pixels(&self, g: *mut c_void, v: u64) -> redjs::webapi::gpu_ext::Pixels {
53 canvas::pixels(g, v)
54 }
55 unsafe fn premul_pixels(&self, g: *mut c_void, v: u64) -> redjs::webapi::gpu_ext::Pixels {
56 canvas::premul_pixels(g, v)
57 }
58 unsafe fn convert_to_blob(&self, g: *mut c_void, ctx: u64, options: u64) -> u64 {
59 canvas::convert_to_blob(g, ctx, options)
60 }
61 unsafe fn transfer_to_image_bitmap(&self, g: *mut c_void, ctx: u64) -> u64 {
62 canvas::transfer(g, ctx)
63 }
64}
65
66#[derive(Clone, Copy, PartialEq, Eq, Hash)]
67enum Kind {
68 Gpu,
69 Canvas,
70 Adapter,
71 Device,
72 Queue,
73 Features,
74 Limits,
75 AdapterInfo,
76 LostInfo,
77 Buffer,
78 Shader,
79 BindGroupLayout,
80 PipelineLayout,
81 BindGroup,
82 ComputePipeline,
83 Encoder,
84 ComputePass,
85 CommandBuffer,
86 Texture,
87 TextureView,
88 Sampler,
89 RenderPipeline,
90 RenderPass,
91 QuerySet,
92 BundleEncoder,
93 Bundle,
94 LanguageFeatures,
95}
96#[derive(Clone)]
97enum Resource {
98 Gpu,
99 Canvas(Arc<canvas::Surface>),
100 Adapter(Arc<Adapter>),
101 Device,
102 Queue,
103 Features(Arc<[&'static str]>),
104 Buffer(Arc<buffer::Buffer>),
105 Shader(compute::Shader),
106 BindGroupLayout(wgpu::BindGroupLayout),
107 PipelineLayout(wgpu::PipelineLayout),
108 BindGroup(compute::BindGroup),
109 ComputePipeline(wgpu::ComputePipeline),
110 Encoder(Arc<Mutex<compute::Encoder>>),
111 ComputePass(Arc<Mutex<compute::ComputePass>>),
112 CommandBuffer(Arc<Mutex<compute::CommandBuffer>>),
113 Texture(Arc<texture::Texture>),
114 TextureView(texture::TextureView),
115 Sampler(wgpu::Sampler),
116 RenderPipeline(wgpu::RenderPipeline),
117 RenderPass(Arc<Mutex<texture::RenderPass>>),
118 QuerySet(Arc<query::QuerySet>),
119 BundleEncoder(Arc<Mutex<bundle::Encoder>>),
120 Bundle(Arc<bundle::Bundle>),
121}
122#[derive(Clone)]
123struct Handle {
124 pub kind: Kind,
125 pub client: Option<Arc<Client>>,
126 pub resource: Resource,
127}
128struct Classes {
129 array_values: u64,
130 s_features: usize,
131 s_limits: usize,
132 s_info: usize,
133 weak_ctor: u64,
134 weak_deref: u64,
135 error_protos: HashMap<&'static str, u64>,
136 hosts: HashMap<Kind, usize>,
137 types: HashMap<Kind, Class>,
138 array_from: u64,
139 s_gpu_canvas: usize,
140 s_gpu_device: usize,
141 s_gpu_texture: usize,
142 s_ranges: usize,
143 s_lost: usize,
144 s_resolve_lost: usize,
145 s_label: usize,
146 s_handlers: usize,
147 s_language: usize,
148 s_reason: usize,
149 pipeline_error_proto: u64,
150}
151unsafe impl Send for Classes {}
152struct Pending {
153 resolve: u64,
154 reject: u64,
155 roots: Vec<u64>,
156}
157struct ClientRef {
158 weak: u64,
159 client: std::sync::Weak<Client>,
160 buffers: Vec<u64>,
161 lost: bool,
162}
163struct Scope {
164 filter: String,
165 error: Option<backend::GpuError>,
166}
167#[derive(Default)]
168struct State {
169 classes: Option<Classes>,
170 pending: HashMap<u64, Pending>,
171 ready: VecDeque<Box<dyn FnOnce(*mut c_void) + Send>>,
172 clients: HashMap<u64, ClientRef>,
173 scopes: HashMap<u64, Vec<Scope>>,
174}
175fn states() -> &'static Mutex<HashMap<usize, State>> {
176 static S: OnceLock<Mutex<HashMap<usize, State>>> = OnceLock::new();
177 S.get_or_init(Default::default)
178}
179
180struct Val {
182 pub g: *mut c_void,
183 pub v: u64,
184}
185impl Val {
186 pub unsafe fn new(g: *mut c_void, v: u64) -> Self {
187 if is_cell(v) {
188 redjs::ffi::redjs_protect(g, v);
189 }
190 Self { g, v }
191 }
192}
193impl Drop for Val {
194 fn drop(&mut self) {
195 if is_cell(self.v) {
196 unsafe {
197 redjs::ffi::redjs_unprotect(self.g, self.v);
198 }
199 }
200 }
201}
202unsafe fn set_i(g: *mut c_void, obj: u64, index: u32, value: u64) {
205 assert_eq!(
206 glue::rjs_define_index(g, obj, index, value),
207 0,
208 "WebGPU internal array property creation failed"
209 );
210}
211unsafe fn field(g: *mut c_void, obj: u64, key: &str) -> Result<Val, ()> {
212 if obj == UNDEF || obj == NULL {
213 return Ok(Val::new(g, UNDEF));
214 }
215 Ok(Val::new(g, try_get(g, obj, key)?))
216}
217unsafe fn text(g: *mut c_void, v: u64, default: &str) -> Result<String, ()> {
218 if v == UNDEF {
219 return Ok(default.into());
220 }
221 let s = to_js_string(g, v)?;
222 Ok(read_string(g, s).unwrap_or_default())
223}
224unsafe fn num(g: *mut c_void, v: u64, default: u64) -> Result<u64, ()> {
225 if v == UNDEF {
226 Ok(default)
227 } else {
228 enforce_range_u64(g, v, "WebGPU integer")
229 }
230}
231unsafe fn uint(g: *mut c_void, v: u64, default: u32) -> Result<u32, ()> {
232 let n = num(g, v, default as u64)?;
233 if n > u32::MAX as u64 {
234 throw_type_error(g, "WebGPU integer exceeds unsigned long");
235 return Err(());
236 }
237 Ok(n as u32)
238}
239unsafe fn boolean(g: *mut c_void, v: u64) -> bool {
240 glue::rjs_to_boolean(g, v) != 0
241}
242unsafe fn seq(g: *mut c_void, v: u64) -> Result<Vec<Val>, ()> {
243 if v == UNDEF {
244 return Ok(Vec::new());
245 }
246 let f = states().lock().unwrap()[&(g as usize)]
247 .classes
248 .as_ref()
249 .unwrap()
250 .array_from;
251 let arr = match call(g, f, UNDEF, &[v]) {
252 Ok(a) => Val::new(g, a),
253 Err(e) => {
254 glue::rjs_throw(g, e);
255 return Err(());
256 }
257 };
258 let n = uint(g, field(g, arr.v, "length")?.v, 0)?;
259 if n > 65536 {
260 throw_type_error(g, "WebGPU descriptor sequence is too large");
261 return Err(());
262 }
263 (0..n).map(|i| field(g, arr.v, &i.to_string())).collect()
264}
265unsafe fn try_handle(g: *mut c_void, v: u64, kind: Kind) -> Option<Handle> {
266 let cls = states()
267 .lock()
268 .unwrap()
269 .get(&(g as usize))
270 .and_then(|s| s.classes.as_ref())
271 .and_then(|c| c.hosts.get(&kind).copied())
272 .map(|c| c as capi::JSClassRef)?;
273 host_data::<Handle>(g, cls, v)
274 .filter(|h| h.kind == kind)
275 .map(|h| h.clone())
276}
277unsafe fn handle(g: *mut c_void, v: u64, kind: Kind) -> Result<Handle, ()> {
278 if let Some(h) = try_handle(g, v, kind) {
279 return Ok(h);
280 }
281 throw_type_error(g, "WebGPU object has the wrong interface or receiver");
282 Err(())
283}
284unsafe fn with_classes<T>(g: *mut c_void, f: impl FnOnce(&Classes) -> T) -> T {
285 f(states().lock().unwrap()[&(g as usize)]
286 .classes
287 .as_ref()
288 .unwrap())
289}
290unsafe fn this(g: *mut c_void, cf: *mut c_void, kind: Kind) -> Result<Handle, ()> {
291 handle(g, cf_this(cf), kind)
292}
293unsafe fn client(g: *mut c_void, h: &Handle) -> Result<Arc<Client>, ()> {
294 let c = h.client.as_ref().unwrap().clone();
295 if let Err(e) = c.check() {
296 redjs::webapi::domexception::throw(g, "InvalidStateError", &e);
297 return Err(());
298 }
299 Ok(c)
300}
301unsafe fn owned(g: *mut c_void, v: u64, kind: Kind, c: &Arc<Client>) -> Result<Handle, ()> {
302 let h = handle(g, v, kind)?;
303 if h.client.as_ref().map(|x| x.id) != Some(c.id) {
304 throw_type_error(g, "WebGPU resource belongs to a different device");
305 return Err(());
306 }
307 Ok(h)
308}
309unsafe fn wrap(g: *mut c_void, kind: Kind, c: Option<Arc<Client>>, r: Resource) -> u64 {
310 let (cls, proto) = {
311 let s = states().lock().unwrap();
312 let cs = s[&(g as usize)].classes.as_ref().unwrap();
313 (cs.hosts[&kind] as capi::JSClassRef, cs.types[&kind].proto)
314 };
315 host_create(
316 g,
317 cls,
318 proto,
319 Handle {
320 kind,
321 client: c,
322 resource: r,
323 },
324 )
325}
326unsafe fn wrap_labeled(
327 g: *mut c_void,
328 kind: Kind,
329 c: Option<Arc<Client>>,
330 r: Resource,
331 label: &str,
332) -> u64 {
333 let o = Val::new(g, wrap(g, kind, c, r));
334 set_label(g, o.v, label);
335 o.v
336}
337unsafe fn set_label(g: *mut c_void, obj: u64, label: &str) {
338 if label.is_empty() {
339 return;
340 }
341 let slot = with_classes(g, |c| c.s_label);
342 let s = Val::new(g, js_string(g, label));
343 glue::rjs_define(g, obj, slot as *mut c_void, s.v, 2);
344}
345unsafe fn object_base(g: *mut c_void, v: u64) -> Result<(), ()> {
346 let hosts: Vec<_> = with_classes(g, |c| c.hosts.values().copied().collect());
347 if hosts
348 .into_iter()
349 .any(|h| host_data::<Handle>(g, h as capi::JSClassRef, v).is_some())
350 {
351 return Ok(());
352 }
353 invalid(g, "WebGPU object has the wrong interface or receiver")
354}
355#[redjs::host_fn]
356unsafe fn label_get(g: *mut c_void, cf: *mut c_void) -> u64 {
357 run(g, || {
358 object_base(g, cf_this(cf))?;
359 let slot = with_classes(g, |c| c.s_label);
360 let v = get_a(g, cf_this(cf), slot as *mut c_void);
361 Ok(if v == UNDEF { js_string(g, "") } else { v })
362 })
363}
364#[redjs::host_fn]
365unsafe fn label_set(g: *mut c_void, cf: *mut c_void) -> u64 {
366 run(g, || {
367 object_base(g, cf_this(cf))?;
368 let s = Val::new(g, to_js_string(g, cf_arg(cf, 0))?);
369 let slot = with_classes(g, |c| c.s_label);
370 glue::rjs_define(g, cf_this(cf), slot as *mut c_void, s.v, 2);
371 Ok(UNDEF)
372 })
373}
374unsafe fn rejected_from_exception(g: *mut c_void) -> u64 {
375 let mut e = UNDEF;
376 if glue::rjs_exception_pending(g, &mut e) == 0 {
377 return UNDEF;
378 }
379 let e = Val::new(g, e);
380 redjs::webapi::domexception::rejected_with(g, e.v)
381}
382unsafe fn invalid(g: *mut c_void, msg: &str) -> Result<(), ()> {
383 throw_type_error(g, msg);
384 Err(())
385}
386fn resource_alive(r: &Resource) -> bool {
390 match r {
391 Resource::Buffer(b) => !b.destroyed.load(Ordering::Acquire),
392 Resource::Texture(t) => !t.destroyed.load(Ordering::Acquire),
393 Resource::TextureView(v) => !v._owner.destroyed.load(Ordering::Acquire),
394 Resource::BindGroup(b) => b._resources.iter().all(resource_alive),
395 Resource::QuerySet(q) => !q.destroyed.load(Ordering::Acquire),
396 Resource::Bundle(b) => b.resources.iter().all(resource_alive),
397 _ => true,
398 }
399}
400unsafe fn validation(g: *mut c_void, c: &Arc<Client>, msg: &str) {
401 route_errors(
402 g,
403 c.id,
404 vec![backend::GpuError {
405 kind: "validation",
406 message: msg.into(),
407 }],
408 );
409}
410unsafe fn checked<T>(g: *mut c_void, c: &Arc<Client>, f: impl FnOnce() -> T) -> T {
411 let out = c.checked(f);
412 route_errors(g, c.id, c.take_errors());
413 out
414}
415unsafe fn error_object(g: *mut c_void, e: backend::GpuError) -> u64 {
416 let name = match e.kind {
417 "out-of-memory" => "GPUOutOfMemoryError",
418 "internal" => "GPUInternalError",
419 _ => "GPUValidationError",
420 };
421 let proto = states().lock().unwrap()[&(g as usize)]
422 .classes
423 .as_ref()
424 .unwrap()
425 .error_protos[name];
426 let o = Val::new(g, new_object(g, proto));
427 define(g, o.v, "message", js_string(g, &e.message), 1 | 2);
428 o.v
429}
430unsafe fn route_errors(g: *mut c_void, id: u64, errors: Vec<backend::GpuError>) {
431 for e in errors {
432 let uncaptured = {
433 let mut ss = states().lock().unwrap();
434 let scopes = ss
435 .get_mut(&(g as usize))
436 .unwrap()
437 .scopes
438 .entry(id)
439 .or_default();
440 if let Some(scope) = scopes.iter_mut().rev().find(|x| x.filter == e.kind) {
441 if scope.error.is_none() {
442 scope.error = Some(e);
443 }
444 None
445 } else {
446 Some(e)
447 }
448 };
449 if let Some(e) = uncaptured {
450 states()
451 .lock()
452 .unwrap()
453 .get_mut(&(g as usize))
454 .unwrap()
455 .ready
456 .push_back(Box::new(move |g| unsafe {
457 if let Some(target) = device_target(g, id) {
458 let error = Val::new(g, error_object(g, e));
459 let event = Val::new(
460 g,
461 redjs::webapi::events::new_trusted_event(g, "uncapturederror"),
462 );
463 define(g, event.v, "error", error.v, 1 | 2);
464 let proto = states().lock().unwrap()[&(g as usize)]
465 .classes
466 .as_ref()
467 .unwrap()
468 .error_protos["GPUUncapturedErrorEvent"];
469 capi::JSObjectSetPrototype(
470 g,
471 event.v as usize as capi::JSObjectRef,
472 proto as usize as capi::JSValueRef,
473 );
474 redjs::webapi::events::dispatch(g, target.v, event.v);
475 }
476 }));
477 }
478 }
479}
480#[redjs::host_fn]
481unsafe fn gpu_error_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
482 run(g, || {
483 let message = text(g, cf_arg(cf, 0), "")?;
484 let o = Val::new(g, ordinary_create(g, cf_new_target(cf), UNDEF));
485 define(g, o.v, "message", js_string(g, &message), 1 | 2);
486 Ok(o.v)
487 })
488}
489#[redjs::host_fn]
490unsafe fn error_event_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
491 run(g, || {
492 let init = Val::new(g, cf_arg(cf, 1));
493 let error = field(g, init.v, "error")?;
494 if !is_cell(error.v) {
495 invalid(g, "GPUUncapturedErrorEvent requires an error")?;
496 }
497 let o = Val::new(
498 g,
499 ordinary_create(
500 g,
501 cf_new_target(cf),
502 redjs::webapi::util::state(g).event.proto,
503 ),
504 );
505 redjs::webapi::events::init_event(g, o.v, cf_arg(cf, 0), init.v, false);
506 define(g, o.v, "error", error.v, 1 | 2);
507 Ok(o.v)
508 })
509}
510
511unsafe fn async_op<T, F, C>(g: *mut c_void, roots: Vec<u64>, work: F, convert: C) -> u64
515where
516 T: Send + 'static,
517 F: std::future::Future<Output = Result<T, String>> + Send + 'static,
518 C: FnOnce(*mut c_void, T) -> u64 + Send + 'static,
519{
520 async_settle(g, roots, work, move |g, value| Ok(convert(g, value)))
521}
522unsafe fn async_settle<T, F, C>(g: *mut c_void, roots: Vec<u64>, work: F, convert: C) -> u64
523where
524 T: Send + 'static,
525 F: std::future::Future<Output = Result<T, String>> + Send + 'static,
526 C: FnOnce(*mut c_void, T) -> Result<u64, u64> + Send + 'static,
527{
528 static NEXT: AtomicU64 = AtomicU64::new(1);
529 let (mut resolve, mut reject, mut p) = (UNDEF, UNDEF, UNDEF);
530 if redjs::ffi::redjs_promise_create(g, &mut resolve, &mut reject, &mut p) != 0 {
531 return UNDEF;
532 }
533 for &v in roots.iter().chain([&resolve, &reject]) {
534 if is_cell(v) {
535 redjs::ffi::redjs_protect(g, v);
536 }
537 }
538 let n = NEXT.fetch_add(1, Ordering::Relaxed);
539 let id = redjs::context::id_of(g);
540 let address = g as usize;
541 states()
542 .lock()
543 .unwrap()
544 .get_mut(&address)
545 .unwrap()
546 .pending
547 .insert(
548 n,
549 Pending {
550 resolve,
551 reject,
552 roots,
553 },
554 );
555 let worker = std::thread::Builder::new()
556 .name("redjs-webgpu".into())
557 .spawn(move || {
558 let result =
559 std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| pollster::block_on(work)))
560 .unwrap_or_else(|_| Err("Native WebGPU asynchronous operation failed".into()));
561 let mut ss = states().lock().unwrap();
562 if redjs::context::id_of(address as *mut c_void) != id {
563 return;
564 }
565 let Some(st) = ss.get_mut(&address) else {
566 return;
567 };
568 st.ready.push_back(Box::new(move |g| unsafe {
569 let pending = states()
570 .lock()
571 .unwrap()
572 .get_mut(&(g as usize))
573 .and_then(|s| s.pending.remove(&n));
574 let Some(pending) = pending else {
575 return;
576 };
577 match result {
578 Ok(value) => {
579 match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
580 convert(g, value)
581 })) {
582 Ok(Ok(value)) => {
583 let value = Val::new(g, value);
584 let _ = call(g, pending.resolve, UNDEF, &[value.v]);
585 }
586 Ok(Err(reason)) => {
587 let reason = Val::new(g, reason);
588 let _ = call(g, pending.reject, UNDEF, &[reason.v]);
589 }
590 Err(_) => {
591 let err = Val::new(
592 g,
593 redjs::webapi::domexception::create(
594 g,
595 "OperationError",
596 "Native WebGPU completion failed",
597 ),
598 );
599 let _ = call(g, pending.reject, UNDEF, &[err.v]);
600 }
601 }
602 }
603 Err(message) => {
604 let err = Val::new(
605 g,
606 redjs::webapi::domexception::create(g, "OperationError", &message),
607 );
608 let _ = call(g, pending.reject, UNDEF, &[err.v]);
609 }
610 }
611 for v in pending
612 .roots
613 .into_iter()
614 .chain([pending.resolve, pending.reject])
615 {
616 if is_cell(v) {
617 redjs::ffi::redjs_unprotect(g, v);
618 }
619 }
620 }));
621 drop(ss);
622 if let Some(id) = id {
623 redjs::web::wake(id);
624 }
625 });
626 if let Err(error) = worker {
627 let pending = states()
628 .lock()
629 .unwrap()
630 .get_mut(&address)
631 .unwrap()
632 .pending
633 .remove(&n)
634 .unwrap();
635 let e = Val::new(
636 g,
637 redjs::webapi::domexception::create(g, "OperationError", &error.to_string()),
638 );
639 let _ = call(g, pending.reject, UNDEF, &[e.v]);
640 for v in pending
641 .roots
642 .into_iter()
643 .chain([pending.resolve, pending.reject])
644 {
645 if is_cell(v) {
646 redjs::ffi::redjs_unprotect(g, v);
647 }
648 }
649 }
650 p
651}
652unsafe fn inflight(g: *mut c_void) -> bool {
653 states()
654 .lock()
655 .unwrap()
656 .get(&(g as usize))
657 .is_some_and(|s| !s.pending.is_empty())
658}
659unsafe fn ready(g: *mut c_void) -> bool {
660 states()
661 .lock()
662 .unwrap()
663 .get(&(g as usize))
664 .is_some_and(|s| {
665 !s.ready.is_empty()
666 || s.clients.values().any(|r| {
667 r.client
668 .upgrade()
669 .is_some_and(|c| c.has_errors() || (!r.lost && c.context.loss().is_some()))
670 })
671 })
672}
673unsafe fn drain(g: *mut c_void) -> usize {
674 let tasks = states()
675 .lock()
676 .unwrap()
677 .get_mut(&(g as usize))
678 .map(|s| std::mem::take(&mut s.ready))
679 .unwrap_or_default();
680 let mut n = tasks.len();
681 for task in tasks {
682 task(g);
683 redjs::web::checkpoint(g);
684 }
685 let clients: Vec<_> = states()
686 .lock()
687 .unwrap()
688 .get(&(g as usize))
689 .map(|s| {
690 s.clients
691 .values()
692 .filter_map(|r| r.client.upgrade())
693 .collect()
694 })
695 .unwrap_or_default();
696 for c in clients {
697 route_errors(g, c.id, c.take_errors());
698 }
699 let ids: Vec<_> = states()
700 .lock()
701 .unwrap()
702 .get(&(g as usize))
703 .map(|s| {
704 s.clients
705 .iter()
706 .filter_map(|(&id, r)| {
707 (!r.lost)
708 .then(|| r.client.upgrade())
709 .flatten()
710 .and_then(|c| c.context.loss().map(|l| (id, l)))
711 })
712 .collect()
713 })
714 .unwrap_or_default();
715 for (id, loss) in ids {
716 release_buffers(g, id);
717 canvas::device_destroyed(id);
718 if let Some(target) = device_target(g, id) {
719 resolve_loss(g, target.v, loss.reason, &loss.message);
720 } else if let Some(r) = states()
721 .lock()
722 .unwrap()
723 .get_mut(&(g as usize))
724 .and_then(|s| s.clients.get_mut(&id))
725 {
726 r.lost = true;
727 }
728 n += 1;
729 }
730 n
731}
732
733#[redjs::host_fn]
734unsafe fn request_adapter(g: *mut c_void, cf: *mut c_void) -> u64 {
735 run(g, || {
736 this(g, cf, Kind::Gpu)?;
737 let o = Val::new(g, cf_arg(cf, 0));
738 let power = text(g, field(g, o.v, "powerPreference")?.v, "")?;
739 let power_preference = match power.as_str() {
740 "" => wgpu::PowerPreference::None,
741 "low-power" => wgpu::PowerPreference::LowPower,
742 "high-performance" => wgpu::PowerPreference::HighPerformance,
743 _ => {
744 invalid(g, "Invalid GPUPowerPreference")?;
745 unreachable!()
746 }
747 };
748 let fallback = boolean(g, field(g, o.v, "forceFallbackAdapter")?.v);
749 Ok(async_op(
750 g,
751 vec![],
752 async move {
753 backend::request_adapter(backend::AdapterOptions {
754 power_preference,
755 force_fallback_adapter: fallback,
756 })
757 .await
758 },
759 |g, a| match a {
760 Some(a) => wrap(g, Kind::Adapter, None, Resource::Adapter(Arc::new(a))),
761 None => NULL,
762 },
763 ))
764 })
765}
766#[redjs::host_fn]
767unsafe fn preferred_format(g: *mut c_void, cf: *mut c_void) -> u64 {
768 run(g, || {
769 this(g, cf, Kind::Gpu)?;
770 Ok(js_string(g, "bgra8unorm"))
771 })
772}
773unsafe fn features_object(g: *mut c_void, features: wgpu::Features) -> u64 {
774 let names = feature_names()
775 .into_iter()
776 .filter(|(_, flag)| features.contains(*flag))
777 .map(|(name, _)| name)
778 .collect();
779 wrap(g, Kind::Features, None, Resource::Features(names))
780}
781unsafe fn feature_flags(g: *mut c_void, cf: *mut c_void) -> Result<Arc<[&'static str]>, ()> {
782 let h = match try_handle(g, cf_this(cf), Kind::LanguageFeatures) {
783 Some(h) => h,
784 None => this(g, cf, Kind::Features)?,
785 };
786 let Resource::Features(f) = h.resource else {
787 unreachable!()
788 };
789 Ok(f)
790}
791#[redjs::host_fn]
792unsafe fn feature_size(g: *mut c_void, cf: *mut c_void) -> u64 {
793 run(g, || Ok(enc_f64(feature_flags(g, cf)?.len() as f64)))
794}
795#[redjs::host_fn]
796unsafe fn feature_has(g: *mut c_void, cf: *mut c_void) -> u64 {
797 run(g, || {
798 let f = feature_flags(g, cf)?;
799 let name = text(g, cf_arg(cf, 0), "")?;
800 Ok(enc_bool(f.iter().any(|n| *n == name)))
801 })
802}
803unsafe fn feature_iterator(g: *mut c_void, cf: *mut c_void, entries: bool) -> Result<u64, ()> {
804 let f = feature_flags(g, cf)?;
805 let a = Val::new(g, new_array(g));
806 for (i, name) in f.iter().copied().enumerate() {
807 let value = Val::new(g, js_string(g, name));
808 if entries {
809 let pair = Val::new(g, new_array(g));
810 set_i(g, pair.v, 0, value.v);
811 set_i(g, pair.v, 1, value.v);
812 set_i(g, a.v, i as u32, pair.v);
813 } else {
814 set_i(g, a.v, i as u32, value.v);
815 }
816 }
817 let values = states().lock().unwrap()[&(g as usize)]
818 .classes
819 .as_ref()
820 .unwrap()
821 .array_values;
822 call(g, values, a.v, &[]).map_err(|e| {
823 glue::rjs_throw(g, e);
824 })
825}
826#[redjs::host_fn]
827unsafe fn feature_values(g: *mut c_void, cf: *mut c_void) -> u64 {
828 run(g, || feature_iterator(g, cf, false))
829}
830#[redjs::host_fn]
831unsafe fn feature_entries(g: *mut c_void, cf: *mut c_void) -> u64 {
832 run(g, || feature_iterator(g, cf, true))
833}
834#[redjs::host_fn]
835unsafe fn feature_each(g: *mut c_void, cf: *mut c_void) -> u64 {
836 run(g, || {
837 let f = feature_flags(g, cf)?;
838 let cb = cf_arg(cf, 0);
839 if glue::rjs_kind(g, cb) != 9 {
840 invalid(g, "GPUSupportedFeatures.forEach requires a callback")?;
841 }
842 for name in f.iter() {
843 let s = Val::new(g, js_string(g, name));
844 call(g, cb, cf_arg(cf, 1), &[s.v, s.v, cf_this(cf)]).map_err(|e| {
845 glue::rjs_throw(g, e);
846 })?;
847 }
848 Ok(UNDEF)
849 })
850}
851unsafe fn cached(g: *mut c_void, obj: u64, slot: usize, build: impl FnOnce() -> u64) -> u64 {
852 let old = get_a(g, obj, slot as *mut c_void);
853 if old != UNDEF {
854 return old;
855 }
856 let v = Val::new(g, build());
857 glue::rjs_define(g, obj, slot as *mut c_void, v.v, 1 | 2);
858 v.v
859}
860unsafe fn plain(g: *mut c_void, kind: Kind) -> u64 {
861 let proto = states().lock().unwrap()[&(g as usize)]
862 .classes
863 .as_ref()
864 .unwrap()
865 .types[&kind]
866 .proto;
867 new_object(g, proto)
868}
869fn feature_names() -> [(&'static str, wgpu::Features); 2] {
872 [
873 ("core-features-and-limits", wgpu::Features::empty()),
874 ("timestamp-query", wgpu::Features::TIMESTAMP_QUERY),
875 ]
876}
877#[redjs::host_fn]
878unsafe fn adapter_features(g: *mut c_void, cf: *mut c_void) -> u64 {
879 run(g, || {
880 let h = this(g, cf, Kind::Adapter)?;
881 let Resource::Adapter(a) = h.resource else {
882 unreachable!()
883 };
884 let slot = with_classes(g, |c| c.s_features);
885 Ok(cached(g, cf_this(cf), slot, || {
886 features_object(g, a.features())
887 }))
888 })
889}
890#[redjs::host_fn]
891unsafe fn wgsl_language_features(g: *mut c_void, cf: *mut c_void) -> u64 {
892 run(g, || {
893 this(g, cf, Kind::Gpu)?;
894 let slot = with_classes(g, |c| c.s_language);
895 Ok(cached(g, cf_this(cf), slot, || {
896 let names = wgpu::naga::front::wgsl::ImplementedLanguageExtension::all()
897 .iter()
898 .map(|e| e.to_ident())
899 .collect();
900 wrap(g, Kind::LanguageFeatures, None, Resource::Features(names))
901 }))
902 })
903}
904#[redjs::host_fn]
905unsafe fn device_features(g: *mut c_void, cf: *mut c_void) -> u64 {
906 run(g, || {
907 let h = this(g, cf, Kind::Device)?;
908 let slot = states().lock().unwrap()[&(g as usize)]
909 .classes
910 .as_ref()
911 .unwrap()
912 .s_features;
913 Ok(cached(g, cf_this(cf), slot, || {
914 features_object(g, h.client.unwrap().features)
915 }))
916 })
917}
918macro_rules! limits_fields {($m:ident)=>{$m!{maxTextureDimension1D=>max_texture_dimension_1d,maxTextureDimension2D=>max_texture_dimension_2d,maxTextureDimension3D=>max_texture_dimension_3d,maxTextureArrayLayers=>max_texture_array_layers,maxBindGroups=>max_bind_groups,maxBindingsPerBindGroup=>max_bindings_per_bind_group,maxDynamicUniformBuffersPerPipelineLayout=>max_dynamic_uniform_buffers_per_pipeline_layout,maxDynamicStorageBuffersPerPipelineLayout=>max_dynamic_storage_buffers_per_pipeline_layout,maxSampledTexturesPerShaderStage=>max_sampled_textures_per_shader_stage,maxSamplersPerShaderStage=>max_samplers_per_shader_stage,maxStorageBuffersPerShaderStage=>max_storage_buffers_per_shader_stage,maxStorageTexturesPerShaderStage=>max_storage_textures_per_shader_stage,maxUniformBuffersPerShaderStage=>max_uniform_buffers_per_shader_stage,maxUniformBufferBindingSize=>max_uniform_buffer_binding_size,maxStorageBufferBindingSize=>max_storage_buffer_binding_size,minUniformBufferOffsetAlignment=>min_uniform_buffer_offset_alignment,minStorageBufferOffsetAlignment=>min_storage_buffer_offset_alignment,maxVertexBuffers=>max_vertex_buffers,maxBufferSize=>max_buffer_size,maxVertexAttributes=>max_vertex_attributes,maxVertexBufferArrayStride=>max_vertex_buffer_array_stride,maxInterStageShaderVariables=>max_inter_stage_shader_variables,maxColorAttachments=>max_color_attachments,maxColorAttachmentBytesPerSample=>max_color_attachment_bytes_per_sample,maxComputeWorkgroupStorageSize=>max_compute_workgroup_storage_size,maxComputeInvocationsPerWorkgroup=>max_compute_invocations_per_workgroup,maxComputeWorkgroupSizeX=>max_compute_workgroup_size_x,maxComputeWorkgroupSizeY=>max_compute_workgroup_size_y,maxComputeWorkgroupSizeZ=>max_compute_workgroup_size_z,maxComputeWorkgroupsPerDimension=>max_compute_workgroups_per_dimension,maxBindGroupsPlusVertexBuffers=>max_bind_groups_plus_vertex_buffers,maxImmediateSize=>max_immediate_size}};}
919fn stage_limit_aliases(l: &wgpu::Limits) -> [(&'static str, u32); 4] {
922 [
923 (
924 "maxStorageBuffersInVertexStage",
925 l.max_storage_buffers_per_shader_stage,
926 ),
927 (
928 "maxStorageBuffersInFragmentStage",
929 l.max_storage_buffers_per_shader_stage,
930 ),
931 (
932 "maxStorageTexturesInVertexStage",
933 l.max_storage_textures_per_shader_stage,
934 ),
935 (
936 "maxStorageTexturesInFragmentStage",
937 l.max_storage_textures_per_shader_stage,
938 ),
939 ]
940}
941unsafe fn limits_object(g: *mut c_void, l: &wgpu::Limits) -> u64 {
942 let o = Val::new(g, plain(g, Kind::Limits));
943 macro_rules! write {($($js:ident=>$rust:ident),*)=>{$(define(g,o.v,stringify!($js),enc_f64(l.$rust as f64),1|2);)*};}
944 limits_fields!(write);
945 for (name, value) in stage_limit_aliases(l) {
946 define(g, o.v, name, enc_f64(value as f64), 1 | 2);
947 }
948 o.v
949}
950#[redjs::host_fn]
951unsafe fn adapter_limits(g: *mut c_void, cf: *mut c_void) -> u64 {
952 run(g, || {
953 let h = this(g, cf, Kind::Adapter)?;
954 let Resource::Adapter(a) = h.resource else {
955 unreachable!()
956 };
957 let slot = states().lock().unwrap()[&(g as usize)]
958 .classes
959 .as_ref()
960 .unwrap()
961 .s_limits;
962 Ok(cached(g, cf_this(cf), slot, || {
963 limits_object(g, &a.limits())
964 }))
965 })
966}
967#[redjs::host_fn]
968unsafe fn device_limits(g: *mut c_void, cf: *mut c_void) -> u64 {
969 run(g, || {
970 let h = this(g, cf, Kind::Device)?;
971 let slot = states().lock().unwrap()[&(g as usize)]
972 .classes
973 .as_ref()
974 .unwrap()
975 .s_limits;
976 Ok(cached(g, cf_this(cf), slot, || {
977 limits_object(g, &h.client.unwrap().limits)
978 }))
979 })
980}
981#[redjs::host_fn]
982unsafe fn adapter_info(g: *mut c_void, cf: *mut c_void) -> u64 {
983 run(g, || {
984 let h = this(g, cf, Kind::Adapter)?;
985 let Resource::Adapter(a) = h.resource else {
986 unreachable!()
987 };
988 let slot = states().lock().unwrap()[&(g as usize)]
989 .classes
990 .as_ref()
991 .unwrap()
992 .s_info;
993 Ok(cached(g, cf_this(cf), slot, || {
994 info_object(g, a.raw.get_info())
995 }))
996 })
997}
998#[redjs::host_fn]
999unsafe fn device_adapter_info(g: *mut c_void, cf: *mut c_void) -> u64 {
1000 run(g, || {
1001 let h = this(g, cf, Kind::Device)?;
1002 let adapter = h.client.unwrap().context.adapter.clone();
1003 let slot = with_classes(g, |c| c.s_info);
1004 Ok(cached(g, cf_this(cf), slot, || {
1005 info_object(g, adapter.get_info())
1006 }))
1007 })
1008}
1009unsafe fn info_object(g: *mut c_void, i: wgpu::AdapterInfo) -> u64 {
1010 let o = Val::new(g, plain(g, Kind::AdapterInfo));
1011 for (k, v) in [
1012 ("vendor", format!("{:x}", i.vendor)),
1013 ("architecture", String::new()),
1014 ("device", format!("{:x}", i.device)),
1015 ("description", i.name),
1016 ] {
1017 define(g, o.v, k, js_string(g, &v), 1 | 2);
1018 }
1019 for (k, v) in [("subgroupMinSize", 4), ("subgroupMaxSize", 128)] {
1021 define(g, o.v, k, enc_f64(v as f64), 1 | 2);
1022 }
1023 define(
1024 g,
1025 o.v,
1026 "isFallbackAdapter",
1027 enc_bool(i.device_type == wgpu::DeviceType::Cpu),
1028 1 | 2,
1029 );
1030 o.v
1031}
1032#[redjs::host_fn]
1033unsafe fn request_device(g: *mut c_void, cf: *mut c_void) -> u64 {
1034 run(g, || {
1035 let h = this(g, cf, Kind::Adapter)?;
1036 let Resource::Adapter(a) = h.resource else {
1037 unreachable!()
1038 };
1039 let d = Val::new(g, cf_arg(cf, 0));
1040 let label = text(g, field(g, d.v, "label")?.v, "")?;
1041 let mut features = wgpu::Features::empty();
1042 let available = a.features();
1043 for v in seq(g, field(g, d.v, "requiredFeatures")?.v)? {
1044 let name = text(g, v.v, "")?;
1045 let Some((_, flag)) = feature_names()
1046 .into_iter()
1047 .find(|(n, flag)| *n == name && available.contains(*flag))
1048 else {
1049 return Ok(redjs::webapi::domexception::rejected(
1050 g,
1051 "NotSupportedError",
1052 &format!("Unsupported WebGPU feature: {name}"),
1053 ));
1054 };
1055 features |= flag;
1056 }
1057 let l = field(g, d.v, "requiredLimits")?;
1058 let adapter_limits = a.limits();
1059 let mut limits = wgpu::Limits {
1060 max_immediate_size: 64.min(adapter_limits.max_immediate_size),
1061 ..Default::default()
1062 };
1063 macro_rules! read {($($js:ident=>$rust:ident),*)=>{$(let v=field(g,l.v,stringify!($js))?;if v.v!=UNDEF {limits.$rust=num(g,v.v,0)?.try_into().map_err(|_|{throw_type_error(g,"WebGPU limit out of range");})?;})*};}
1064 limits_fields!(read);
1065 for (name, available) in stage_limit_aliases(&adapter_limits) {
1066 let v = field(g, l.v, name)?;
1067 if v.v != UNDEF && num(g, v.v, 0)? > available as u64 {
1068 return Ok(redjs::webapi::domexception::rejected(
1069 g,
1070 "OperationError",
1071 &format!("Unsupported requiredLimits: {name}"),
1072 ));
1073 }
1074 }
1075 let queue = field(g, d.v, "defaultQueue")?;
1076 let queue_label = text(g, field(g, queue.v, "label")?.v, "")?;
1077 let client_limits = limits.clone();
1078 Ok(async_op(
1079 g,
1080 vec![],
1081 async move { a.request_device(features, limits).await },
1082 move |g, context| {
1083 let device = Val::new(
1084 g,
1085 make_device(
1086 g,
1087 Client::new_with_capabilities(context, features, client_limits),
1088 ),
1089 );
1090 set_label(g, device.v, &label);
1091 set_label(g, get(g, device.v, "queue"), &queue_label);
1092 device.v
1093 },
1094 ))
1095 })
1096}
1097unsafe fn make_device(g: *mut c_void, c: Arc<Client>) -> u64 {
1098 prune_clients(g);
1099 let o = Val::new(g, wrap(g, Kind::Device, Some(c.clone()), Resource::Device));
1100 let queue = Val::new(g, wrap(g, Kind::Queue, Some(c.clone()), Resource::Queue));
1101 define(g, o.v, "queue", queue.v, 1 | 2);
1102 let (mut res, mut rej, mut p) = (UNDEF, UNDEF, UNDEF);
1103 redjs::ffi::redjs_promise_create(g, &mut res, &mut rej, &mut p);
1104 let pr = Val::new(g, p);
1105 let rr = Val::new(g, res);
1106 let (sl, sr) = {
1107 let s = states().lock().unwrap();
1108 let c = s[&(g as usize)].classes.as_ref().unwrap();
1109 (c.s_lost, c.s_resolve_lost)
1110 };
1111 glue::rjs_define(g, o.v, sl as *mut c_void, pr.v, 1 | 2);
1112 glue::rjs_define(g, pr.v, sl as *mut c_void, o.v, 1 | 2);
1113 glue::rjs_define(g, o.v, sr as *mut c_void, rr.v, 1 | 2);
1114 let weak = weak_ref(g, o.v);
1115 states()
1116 .lock()
1117 .unwrap()
1118 .get_mut(&(g as usize))
1119 .unwrap()
1120 .clients
1121 .insert(
1122 c.id,
1123 ClientRef {
1124 weak,
1125 client: Arc::downgrade(&c),
1126 buffers: Vec::new(),
1127 lost: false,
1128 },
1129 );
1130 o.v
1131}
1132#[redjs::host_fn]
1133unsafe fn lost(g: *mut c_void, cf: *mut c_void) -> u64 {
1134 run(g, || {
1135 this(g, cf, Kind::Device)?;
1136 let sl = states().lock().unwrap()[&(g as usize)]
1137 .classes
1138 .as_ref()
1139 .unwrap()
1140 .s_lost;
1141 Ok(get_a(g, cf_this(cf), sl as *mut c_void))
1142 })
1143}
1144unsafe fn prune_clients(g: *mut c_void) {
1145 let dead = {
1146 let mut s = states().lock().unwrap();
1147 let s = s.get_mut(&(g as usize)).unwrap();
1148 let ids: Vec<_> = s
1149 .clients
1150 .iter()
1151 .filter_map(|(&id, r)| (r.client.strong_count() == 0).then_some(id))
1152 .collect();
1153 ids.into_iter()
1154 .map(|id| {
1155 s.scopes.remove(&id);
1156 s.clients.remove(&id).unwrap()
1157 })
1158 .collect::<Vec<_>>()
1159 };
1160 for r in dead {
1161 for v in r.buffers.into_iter().chain([r.weak]) {
1162 redjs::ffi::redjs_unprotect(g, v);
1163 }
1164 }
1165}
1166unsafe fn weak_ref(g: *mut c_void, obj: u64) -> u64 {
1167 let ctor = states().lock().unwrap()[&(g as usize)]
1168 .classes
1169 .as_ref()
1170 .unwrap()
1171 .weak_ctor;
1172 let mut out = UNDEF;
1173 if glue::rjs_construct(g, ctor, &obj, 1, &mut out) != 0 {
1174 panic!("Intrinsic WeakRef construction failed");
1175 }
1176 redjs::ffi::redjs_protect(g, out);
1177 out
1178}
1179unsafe fn deref(g: *mut c_void, weak: u64) -> Val {
1180 let f = states().lock().unwrap()[&(g as usize)]
1181 .classes
1182 .as_ref()
1183 .unwrap()
1184 .weak_deref;
1185 Val::new(g, call(g, f, weak, &[]).unwrap_or(UNDEF))
1186}
1187unsafe fn device_target(g: *mut c_void, id: u64) -> Option<Val> {
1188 let weak = states()
1189 .lock()
1190 .unwrap()
1191 .get(&(g as usize))?
1192 .clients
1193 .get(&id)?
1194 .weak;
1195 let v = deref(g, weak);
1196 is_cell(v.v).then_some(v)
1197}
1198unsafe fn track_buffer_object(g: *mut c_void, c: &Arc<Client>, obj: u64) {
1199 let weak = weak_ref(g, obj);
1200 let old = {
1201 let mut s = states().lock().unwrap();
1202 let r = s
1203 .get_mut(&(g as usize))
1204 .unwrap()
1205 .clients
1206 .get_mut(&c.id)
1207 .unwrap();
1208 r.buffers.push(weak);
1209 if r.buffers.len() % 64 == 0 {
1210 std::mem::take(&mut r.buffers)
1211 } else {
1212 Vec::new()
1213 }
1214 };
1215 let mut live = Vec::new();
1216 for w in old {
1217 if is_cell(deref(g, w).v) {
1218 live.push(w)
1219 } else {
1220 redjs::ffi::redjs_unprotect(g, w);
1221 }
1222 }
1223 if !live.is_empty() {
1224 states()
1225 .lock()
1226 .unwrap()
1227 .get_mut(&(g as usize))
1228 .unwrap()
1229 .clients
1230 .get_mut(&c.id)
1231 .unwrap()
1232 .buffers
1233 .extend(live);
1234 }
1235}
1236unsafe fn release_buffers(g: *mut c_void, id: u64) {
1237 let buffers = states()
1238 .lock()
1239 .unwrap()
1240 .get_mut(&(g as usize))
1241 .and_then(|s| s.clients.get_mut(&id))
1242 .map(|r| std::mem::take(&mut r.buffers))
1243 .unwrap_or_default();
1244 for w in buffers {
1245 let o = deref(g, w);
1246 if is_cell(o.v) {
1247 buffer::release_on_device_destroy(g, o.v);
1248 }
1249 redjs::ffi::redjs_unprotect(g, w);
1250 }
1251}
1252unsafe fn resolve_loss(g: *mut c_void, target: u64, reason: &str, message: &str) {
1253 let sr = states().lock().unwrap()[&(g as usize)]
1254 .classes
1255 .as_ref()
1256 .unwrap()
1257 .s_resolve_lost;
1258 let res = Val::new(g, get_a(g, target, sr as *mut c_void));
1259 let info = Val::new(g, plain(g, Kind::LostInfo));
1260 define(g, info.v, "reason", js_string(g, reason), 1 | 2);
1261 define(g, info.v, "message", js_string(g, message), 1 | 2);
1262 let _ = call(g, res.v, UNDEF, &[info.v]);
1263 if let Ok(h) = handle(g, target, Kind::Device) {
1264 let id = h.client.unwrap().id;
1265 if let Some(r) = states()
1266 .lock()
1267 .unwrap()
1268 .get_mut(&(g as usize))
1269 .and_then(|s| s.clients.get_mut(&id))
1270 {
1271 r.lost = true;
1272 }
1273 }
1274}
1275#[redjs::host_fn]
1276unsafe fn destroy(g: *mut c_void, cf: *mut c_void) -> u64 {
1277 run(g, || {
1278 let h = this(g, cf, Kind::Device)?;
1279 let c = h.client.unwrap();
1280 release_buffers(g, c.id);
1281 c.destroy();
1282 canvas::device_destroyed(c.id);
1283 resolve_loss(
1284 g,
1285 cf_this(cf),
1286 "destroyed",
1287 "Logical WebGPU device was destroyed",
1288 );
1289 Ok(UNDEF)
1290 })
1291}
1292#[redjs::host_fn]
1293unsafe fn uncaptured_handler_get(g: *mut c_void, cf: *mut c_void) -> u64 {
1294 run(g, || {
1295 this(g, cf, Kind::Device)?;
1296 let slot = with_classes(g, |c| c.s_handlers);
1297 let v = get_a(g, cf_this(cf), slot as *mut c_void);
1298 Ok(if v == UNDEF { NULL } else { v })
1299 })
1300}
1301#[redjs::host_fn]
1302unsafe fn uncaptured_handler_set(g: *mut c_void, cf: *mut c_void) -> u64 {
1303 run(g, || {
1304 this(g, cf, Kind::Device)?;
1305 let v = cf_arg(cf, 0);
1306 let v = if redjs::webapi::events::is_callable(g, v) {
1307 v
1308 } else {
1309 NULL
1310 };
1311 let slot = with_classes(g, |c| c.s_handlers);
1312 glue::rjs_define(g, cf_this(cf), slot as *mut c_void, v, 2);
1313 Ok(UNDEF)
1314 })
1315}
1316unsafe fn pipeline_error(g: *mut c_void, reason: &str, message: &str) -> u64 {
1317 let (proto, slot) = with_classes(g, |c| (c.pipeline_error_proto, c.s_reason));
1318 let e = Val::new(
1319 g,
1320 redjs::webapi::domexception::create(g, "GPUPipelineError", message),
1321 );
1322 capi::JSObjectSetPrototype(
1323 g,
1324 e.v as usize as capi::JSObjectRef,
1325 proto as usize as capi::JSValueRef,
1326 );
1327 let r = Val::new(g, js_string(g, reason));
1328 glue::rjs_define(g, e.v, slot as *mut c_void, r.v, 1 | 2);
1329 e.v
1330}
1331#[redjs::host_fn]
1332unsafe fn pipeline_error_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
1333 run(g, || {
1334 let message = text(g, cf_arg(cf, 0), "")?;
1335 let options = Val::new(g, cf_arg(cf, 1));
1336 if !is_cell(options.v) {
1337 invalid(g, "GPUPipelineError requires a GPUPipelineErrorInit")?;
1338 }
1339 let reason = field(g, options.v, "reason")?;
1340 if reason.v == UNDEF {
1341 invalid(g, "GPUPipelineErrorInit.reason is required")?;
1342 }
1343 let reason = text(g, reason.v, "")?;
1344 if reason != "validation" && reason != "internal" {
1345 invalid(g, "Invalid GPUPipelineErrorReason")?;
1346 }
1347 let e = Val::new(g, pipeline_error(g, &reason, &message));
1348 let target = cf_new_target(cf);
1349 if is_cell(target) {
1350 let proto = get(g, target, "prototype");
1351 if is_cell(proto) {
1352 capi::JSObjectSetPrototype(
1353 g,
1354 e.v as usize as capi::JSObjectRef,
1355 proto as usize as capi::JSValueRef,
1356 );
1357 }
1358 }
1359 Ok(e.v)
1360 })
1361}
1362#[redjs::host_fn]
1363unsafe fn pipeline_error_reason(g: *mut c_void, cf: *mut c_void) -> u64 {
1364 run(g, || {
1365 let slot = with_classes(g, |c| c.s_reason);
1366 let this = cf_this(cf);
1367 let v = if is_cell(this) {
1368 get_a(g, this, slot as *mut c_void)
1369 } else {
1370 UNDEF
1371 };
1372 if v == UNDEF {
1373 invalid(
1374 g,
1375 "GPUPipelineError.reason called on an incompatible receiver",
1376 )?;
1377 }
1378 Ok(v)
1379 })
1380}
1381#[redjs::host_fn]
1382unsafe fn push_scope(g: *mut c_void, cf: *mut c_void) -> u64 {
1383 run(g, || {
1384 let h = this(g, cf, Kind::Device)?;
1385 let c = h.client.as_ref().unwrap();
1386 route_errors(g, c.id, c.take_errors());
1387 let filter = text(g, cf_arg(cf, 0), "")?;
1388 if !["validation", "out-of-memory", "internal"].contains(&filter.as_str()) {
1389 invalid(g, "Invalid GPUErrorFilter")?;
1390 }
1391 states()
1392 .lock()
1393 .unwrap()
1394 .get_mut(&(g as usize))
1395 .unwrap()
1396 .scopes
1397 .entry(h.client.unwrap().id)
1398 .or_default()
1399 .push(Scope {
1400 filter,
1401 error: None,
1402 });
1403 Ok(UNDEF)
1404 })
1405}
1406#[redjs::host_fn]
1407unsafe fn pop_scope(g: *mut c_void, cf: *mut c_void) -> u64 {
1408 run(g, || {
1409 let h = this(g, cf, Kind::Device)?;
1410 let scope = states()
1411 .lock()
1412 .unwrap()
1413 .get_mut(&(g as usize))
1414 .unwrap()
1415 .scopes
1416 .entry(h.client.unwrap().id)
1417 .or_default()
1418 .pop();
1419 let Some(scope) = scope else {
1420 return Ok(redjs::webapi::domexception::rejected(
1421 g,
1422 "OperationError",
1423 "No WebGPU error scope to pop",
1424 ));
1425 };
1426 let value = Val::new(g, scope.error.map_or(NULL, |e| error_object(g, e)));
1427 Ok(resolved_promise(g, value.v))
1428 })
1429}
1430unsafe fn run(g: *mut c_void, f: impl FnOnce() -> Result<u64, ()>) -> u64 {
1433 match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) {
1434 Ok(Ok(v)) => v,
1435 Ok(Err(())) => UNDEF,
1436 Err(payload) => {
1437 let reason = payload
1438 .downcast_ref::<String>()
1439 .map(String::as_str)
1440 .or_else(|| payload.downcast_ref::<&str>().copied())
1441 .unwrap_or("an internal error");
1442 let reason = reason.split_whitespace().collect::<Vec<_>>().join(" ");
1443 redjs::webapi::domexception::throw(
1444 g,
1445 "OperationError",
1446 &format!("Native WebGPU operation failed: {reason}"),
1447 )
1448 }
1449 }
1450}
1451
1452unsafe extern "C" fn finalize_handle(obj: capi::JSObjectRef) {
1453 let p = capi::JSObjectGetPrivate(obj);
1454 if !p.is_null() {
1455 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
1456 drop(Box::from_raw(p as *mut Handle))
1457 }));
1458 }
1459}
1460unsafe fn make_gpu_host_class(name: &str) -> capi::JSClassRef {
1461 let name = std::ffi::CString::new(name).unwrap();
1462 let mut d = capi::JSClassDefinition::empty();
1463 d.class_name = name.as_ptr();
1464 d.finalize = Some(finalize_handle);
1465 capi::JSClassCreate(&d)
1466}
1467
1468pub(crate) unsafe fn install(g: *mut c_void) {
1469 states()
1470 .lock()
1471 .unwrap()
1472 .insert(g as usize, State::default());
1473 let global = glue::rjs_global(g);
1474 let array = Val::new(g, get(g, global, "Array"));
1475 let from = Val::new(g, get(g, array.v, "from"));
1476 redjs::ffi::redjs_protect(g, from.v);
1477 let weak_ctor = Val::new(g, get(g, global, "WeakRef"));
1478 let weak_proto = field(g, weak_ctor.v, "prototype").unwrap();
1479 let weak_deref = field(g, weak_proto.v, "deref").unwrap();
1480 for v in [weak_ctor.v, weak_deref.v] {
1481 redjs::ffi::redjs_protect(g, v);
1482 }
1483 let ap = field(g, array.v, "prototype").unwrap();
1484 let array_values = field(g, ap.v, "values").unwrap();
1485 redjs::ffi::redjs_protect(g, array_values.v);
1486 let classes = Classes {
1487 array_values: array_values.v,
1488 s_features: atom_priv(g, "webgpu.features") as usize,
1489 s_limits: atom_priv(g, "webgpu.limits") as usize,
1490 s_info: atom_priv(g, "webgpu.info") as usize,
1491 weak_ctor: weak_ctor.v,
1492 weak_deref: weak_deref.v,
1493 error_protos: HashMap::new(),
1494 hosts: HashMap::new(),
1495 types: HashMap::new(),
1496 array_from: from.v,
1497 s_gpu_canvas: atom_priv(g, "webgpu.canvas") as usize,
1498 s_gpu_device: atom_priv(g, "webgpu.canvasDevice") as usize,
1499 s_gpu_texture: atom_priv(g, "webgpu.canvasTexture") as usize,
1500 s_ranges: atom_priv(g, "webgpu.ranges") as usize,
1501 s_lost: atom_priv(g, "webgpu.lost") as usize,
1502 s_resolve_lost: atom_priv(g, "webgpu.resolveLost") as usize,
1503 s_label: atom_priv(g, "webgpu.label") as usize,
1504 s_handlers: atom_priv(g, "webgpu.onuncapturederror") as usize,
1505 s_language: atom_priv(g, "webgpu.wgslLanguageFeatures") as usize,
1506 s_reason: atom_priv(g, "webgpu.pipelineErrorReason") as usize,
1507 pipeline_error_proto: 0,
1508 };
1509 states()
1510 .lock()
1511 .unwrap()
1512 .get_mut(&(g as usize))
1513 .unwrap()
1514 .classes = Some(classes);
1515 class(
1516 g,
1517 Kind::Gpu,
1518 "GPU",
1519 &[
1520 ("requestAdapter", 0, request_adapter),
1521 ("getPreferredCanvasFormat", 0, preferred_format),
1522 ],
1523 &[("wgslLanguageFeatures", wgsl_language_features)],
1524 );
1525 class(
1526 g,
1527 Kind::Adapter,
1528 "GPUAdapter",
1529 &[("requestDevice", 0, request_device)],
1530 &[
1531 ("features", adapter_features),
1532 ("limits", adapter_limits),
1533 ("info", adapter_info),
1534 ],
1535 );
1536 class(
1537 g,
1538 Kind::Device,
1539 "GPUDevice",
1540 &[
1541 ("destroy", 0, destroy),
1542 ("pushErrorScope", 1, push_scope),
1543 ("popErrorScope", 0, pop_scope),
1544 ],
1545 &[
1546 ("features", device_features),
1547 ("limits", device_limits),
1548 ("lost", lost),
1549 ("adapterInfo", device_adapter_info),
1550 ],
1551 );
1552 let device_proto = with_classes(g, |c| c.types[&Kind::Device].proto);
1553 let a = atom(g, "onuncapturederror");
1554 glue::rjs_define_accessor(
1555 g,
1556 device_proto,
1557 a,
1558 make_fn(g, "get onuncapturederror", 0, uncaptured_handler_get),
1559 make_fn(g, "set onuncapturederror", 1, uncaptured_handler_set),
1560 2,
1561 );
1562 glue::rjs_atom_free(g, a);
1563 class(g, Kind::Queue, "GPUQueue", &[], &[]);
1564 for (kind, name) in [
1565 (Kind::Features, "GPUSupportedFeatures"),
1566 (Kind::LanguageFeatures, "WGSLLanguageFeatures"),
1567 ] {
1568 class(
1569 g,
1570 kind,
1571 name,
1572 &[
1573 ("has", 1, feature_has),
1574 ("keys", 0, feature_values),
1575 ("values", 0, feature_values),
1576 ("entries", 0, feature_entries),
1577 ("forEach", 1, feature_each),
1578 ],
1579 &[("size", feature_size)],
1580 );
1581 let proto = with_classes(g, |c| c.types[&kind].proto);
1582 let iter = glue::rjs_atom_iterator(g);
1583 glue::rjs_define(g, proto, iter, make_fn(g, "values", 0, feature_values), 2);
1584 glue::rjs_atom_free(g, iter);
1585 }
1586 class(g, Kind::Limits, "GPUSupportedLimits", &[], &[]);
1587 class(g, Kind::AdapterInfo, "GPUAdapterInfo", &[], &[]);
1588 class(g, Kind::LostInfo, "GPUDeviceLostInfo", &[], &[]);
1589 let base = define_class(
1590 g,
1591 &ClassSpec {
1592 name: "GPUError",
1593 arity: 0,
1594 construct: None,
1595 parent_proto: 0,
1596 methods: &[],
1597 getters: &[],
1598 accessors: &[],
1599 },
1600 );
1601 for name in [
1602 "GPUValidationError",
1603 "GPUOutOfMemoryError",
1604 "GPUInternalError",
1605 ] {
1606 let c = define_class(
1607 g,
1608 &ClassSpec {
1609 name,
1610 arity: 1,
1611 construct: Some(gpu_error_construct),
1612 parent_proto: base.proto,
1613 methods: &[],
1614 getters: &[],
1615 accessors: &[],
1616 },
1617 );
1618 states()
1619 .lock()
1620 .unwrap()
1621 .get_mut(&(g as usize))
1622 .unwrap()
1623 .classes
1624 .as_mut()
1625 .unwrap()
1626 .error_protos
1627 .insert(name, c.proto);
1628 }
1629 let event_class = define_class(
1630 g,
1631 &ClassSpec {
1632 name: "GPUUncapturedErrorEvent",
1633 arity: 2,
1634 construct: Some(error_event_construct),
1635 parent_proto: redjs::webapi::util::state(g).event.proto,
1636 methods: &[],
1637 getters: &[],
1638 accessors: &[],
1639 },
1640 );
1641 states()
1642 .lock()
1643 .unwrap()
1644 .get_mut(&(g as usize))
1645 .unwrap()
1646 .classes
1647 .as_mut()
1648 .unwrap()
1649 .error_protos
1650 .insert("GPUUncapturedErrorEvent", event_class.proto);
1651 let dom_exception = Val::new(g, get(g, global, "DOMException"));
1652 let dom_proto = field(g, dom_exception.v, "prototype").unwrap();
1653 let pipeline_error_class = define_class(
1654 g,
1655 &ClassSpec {
1656 name: "GPUPipelineError",
1657 arity: 2,
1658 construct: Some(pipeline_error_construct),
1659 parent_proto: dom_proto.v,
1660 methods: &[],
1661 getters: &[("reason", pipeline_error_reason)],
1662 accessors: &[],
1663 },
1664 );
1665 states()
1666 .lock()
1667 .unwrap()
1668 .get_mut(&(g as usize))
1669 .unwrap()
1670 .classes
1671 .as_mut()
1672 .unwrap()
1673 .pipeline_error_proto = pipeline_error_class.proto;
1674 buffer::install(g);
1675 compute::install(g);
1676 texture::install(g);
1677 query::install(g);
1678 bundle::install(g);
1679 canvas::install(g);
1680 let nav = Val::new(g, get(g, global, "navigator"));
1681 let gpu = wrap(g, Kind::Gpu, None, Resource::Gpu);
1682 define(g, nav.v, "gpu", gpu, 1 | 2);
1683 redjs::web::register_pump_source(redjs::web::PumpSource {
1684 inflight,
1685 ready,
1686 drain,
1687 });
1688}
1689unsafe fn class(
1690 g: *mut c_void,
1691 kind: Kind,
1692 name: &str,
1693 methods: &[(&str, u32, HostFn)],
1694 getters: &[(&str, HostFn)],
1695) {
1696 let host = make_gpu_host_class(name) as usize;
1697 let parent = if kind == Kind::Device {
1698 redjs::webapi::util::state(g).event_target.proto
1699 } else {
1700 0
1701 };
1702 let object_base = !matches!(
1703 kind,
1704 Kind::Gpu
1705 | Kind::Canvas
1706 | Kind::Adapter
1707 | Kind::Features
1708 | Kind::LanguageFeatures
1709 | Kind::Limits
1710 | Kind::AdapterInfo
1711 | Kind::LostInfo
1712 );
1713 let label: &[(&str, HostFn, HostFn)] = &[("label", label_get, label_set)];
1714 let c = define_class(
1715 g,
1716 &ClassSpec {
1717 name,
1718 arity: 0,
1719 construct: None,
1720 parent_proto: parent,
1721 methods,
1722 getters,
1723 accessors: if object_base { label } else { &[] },
1724 },
1725 );
1726 states()
1727 .lock()
1728 .unwrap()
1729 .get_mut(&(g as usize))
1730 .unwrap()
1731 .classes
1732 .as_mut()
1733 .unwrap()
1734 .hosts
1735 .insert(kind, host);
1736 states()
1737 .lock()
1738 .unwrap()
1739 .get_mut(&(g as usize))
1740 .unwrap()
1741 .classes
1742 .as_mut()
1743 .unwrap()
1744 .types
1745 .insert(kind, c);
1746}
1747unsafe fn method(g: *mut c_void, kind: Kind, name: &str, arity: u32, f: HostFn) {
1748 let proto = states().lock().unwrap()[&(g as usize)]
1749 .classes
1750 .as_ref()
1751 .unwrap()
1752 .types[&kind]
1753 .proto;
1754 define(g, proto, name, make_fn(g, name, arity, f), 2);
1755}
1756unsafe fn constants(g: *mut c_void, name: &str, values: &[(&str, u32)]) {
1757 let o = Val::new(g, new_object(g, UNDEF));
1758 for &(n, v) in values {
1759 define(g, o.v, n, enc_f64(v as f64), 1 | 2 | 4);
1760 }
1761 define(g, glue::rjs_global(g), name, o.v, 1 | 2);
1762}
1763pub(crate) fn forget(gone: redjs::context::Gone) {
1764 canvas::forget(gone);
1765 let s = states().lock().unwrap().remove(&gone.key);
1766 if let Some(s) = s {
1767 for r in s.clients.values() {
1768 if let Some(c) = r.client.upgrade() {
1769 c.destroy();
1770 }
1771 }
1772 if let Some(c) = s.classes {
1773 unsafe {
1774 for host in c.hosts.into_values() {
1775 capi::JSClassRelease(host as capi::JSClassRef);
1776 }
1777 }
1778 }
1779 }
1780}