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