//! Native WebGPU over the same wgpu revision as the host renderer.
//!
//! Opt-in while canvas presentation is being integrated. JSC objects own logical
//! clients, not the physical device: embedders may supply an existing context.
//! WGSL always goes through wgpu validation; no shader passthrough is exposed.
//!
//! [`register`] once, before the contexts that should have WebGPU are installed.
pub mod backend;
mod buffer;
mod bundle;
pub mod canvas;
mod compute;
mod query;
mod readback;
#[cfg(test)]
mod tests;
mod texture;
use backend::{Adapter, Client};
use core::ffi::c_void;
use redjs::webapi::util::*;
use redjs::{capi, glue};
use std::collections::{HashMap, VecDeque};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
/// Makes every redjs context installed after this call carry `navigator.gpu`.
pub fn register() {
redjs::webapi::gpu_ext::register(&Extension);
}
struct Extension;
impl redjs::webapi::gpu_ext::GpuExtension for Extension {
unsafe fn install(&self, g: *mut c_void) {
install(g);
}
fn forget(&self, gone: redjs::context::Gone) {
forget(gone);
}
unsafe fn pump(&self, g: *mut c_void) {
canvas::pump(g);
}
unsafe fn create_context(&self, g: *mut c_void, owner: u64, w: u32, h: u32) -> u64 {
canvas::create(g, owner, w, h, None)
}
unsafe fn resize(&self, g: *mut c_void, ctx: u64, w: u32, h: u32) {
let _ = canvas::resize(g, ctx, w, h);
}
unsafe fn is_context(&self, g: *mut c_void, v: u64) -> bool {
canvas::is_context(g, v)
}
unsafe fn pixels(&self, g: *mut c_void, v: u64) -> redjs::webapi::gpu_ext::Pixels {
canvas::pixels(g, v)
}
unsafe fn premul_pixels(&self, g: *mut c_void, v: u64) -> redjs::webapi::gpu_ext::Pixels {
canvas::premul_pixels(g, v)
}
unsafe fn convert_to_blob(&self, g: *mut c_void, ctx: u64, options: u64) -> u64 {
canvas::convert_to_blob(g, ctx, options)
}
unsafe fn transfer_to_image_bitmap(&self, g: *mut c_void, ctx: u64) -> u64 {
canvas::transfer(g, ctx)
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
enum Kind {
Gpu,
Canvas,
Adapter,
Device,
Queue,
Features,
Limits,
AdapterInfo,
LostInfo,
Buffer,
Shader,
BindGroupLayout,
PipelineLayout,
BindGroup,
ComputePipeline,
Encoder,
ComputePass,
CommandBuffer,
Texture,
TextureView,
Sampler,
RenderPipeline,
RenderPass,
QuerySet,
BundleEncoder,
Bundle,
LanguageFeatures,
}
#[derive(Clone)]
enum Resource {
Gpu,
Canvas(Arc<canvas::Surface>),
Adapter(Arc<Adapter>),
Device,
Queue,
Features(Arc<[&'static str]>),
Buffer(Arc<buffer::Buffer>),
Shader(compute::Shader),
BindGroupLayout(wgpu::BindGroupLayout),
PipelineLayout(wgpu::PipelineLayout),
BindGroup(compute::BindGroup),
ComputePipeline(wgpu::ComputePipeline),
Encoder(Arc<Mutex<compute::Encoder>>),
ComputePass(Arc<Mutex<compute::ComputePass>>),
CommandBuffer(Arc<Mutex<compute::CommandBuffer>>),
Texture(Arc<texture::Texture>),
TextureView(texture::TextureView),
Sampler(wgpu::Sampler),
RenderPipeline(wgpu::RenderPipeline),
RenderPass(Arc<Mutex<texture::RenderPass>>),
QuerySet(Arc<query::QuerySet>),
BundleEncoder(Arc<Mutex<bundle::Encoder>>),
Bundle(Arc<bundle::Bundle>),
}
#[derive(Clone)]
struct Handle {
pub kind: Kind,
pub client: Option<Arc<Client>>,
pub resource: Resource,
}
struct Classes {
array_values: u64,
s_features: usize,
s_limits: usize,
s_info: usize,
weak_ctor: u64,
weak_deref: u64,
error_protos: HashMap<&'static str, u64>,
hosts: HashMap<Kind, usize>,
types: HashMap<Kind, Class>,
array_from: u64,
s_gpu_canvas: usize,
s_gpu_device: usize,
s_gpu_texture: usize,
s_ranges: usize,
s_lost: usize,
s_resolve_lost: usize,
s_label: usize,
s_handlers: usize,
s_language: usize,
s_reason: usize,
pipeline_error_proto: u64,
}
unsafe impl Send for Classes {}
struct Pending {
resolve: u64,
reject: u64,
roots: Vec<u64>,
}
struct ClientRef {
weak: u64,
client: std::sync::Weak<Client>,
buffers: Vec<u64>,
lost: bool,
}
struct Scope {
filter: String,
error: Option<backend::GpuError>,
}
#[derive(Default)]
struct State {
classes: Option<Classes>,
pending: HashMap<u64, Pending>,
ready: VecDeque<Box<dyn FnOnce(*mut c_void) + Send>>,
clients: HashMap<u64, ClientRef>,
scopes: HashMap<u64, Vec<Scope>>,
}
fn states() -> &'static Mutex<HashMap<usize, State>> {
static S: OnceLock<Mutex<HashMap<usize, State>>> = OnceLock::new();
S.get_or_init(Default::default)
}
/// A temporary GC root. Descriptor getters may allocate, force GC, or reenter.
struct Val {
pub g: *mut c_void,
pub v: u64,
}
impl Val {
pub unsafe fn new(g: *mut c_void, v: u64) -> Self {
if is_cell(v) {
redjs::ffi::redjs_protect(g, v);
}
Self { g, v }
}
}
impl Drop for Val {
fn drop(&mut self) {
if is_cell(self.v) {
unsafe {
redjs::ffi::redjs_unprotect(self.g, self.v);
}
}
}
}
// Internal arrays are GC edges. Create own data properties rather than invoking
// an application-defined Array.prototype[index] setter.
unsafe fn set_i(g: *mut c_void, obj: u64, index: u32, value: u64) {
assert_eq!(
glue::rjs_define_index(g, obj, index, value),
0,
"WebGPU internal array property creation failed"
);
}
unsafe fn field(g: *mut c_void, obj: u64, key: &str) -> Result<Val, ()> {
if obj == UNDEF || obj == NULL {
return Ok(Val::new(g, UNDEF));
}
Ok(Val::new(g, try_get(g, obj, key)?))
}
unsafe fn text(g: *mut c_void, v: u64, default: &str) -> Result<String, ()> {
if v == UNDEF {
return Ok(default.into());
}
let s = to_js_string(g, v)?;
Ok(read_string(g, s).unwrap_or_default())
}
unsafe fn num(g: *mut c_void, v: u64, default: u64) -> Result<u64, ()> {
if v == UNDEF {
Ok(default)
} else {
enforce_range_u64(g, v, "WebGPU integer")
}
}
unsafe fn uint(g: *mut c_void, v: u64, default: u32) -> Result<u32, ()> {
let n = num(g, v, default as u64)?;
if n > u32::MAX as u64 {
throw_type_error(g, "WebGPU integer exceeds unsigned long");
return Err(());
}
Ok(n as u32)
}
unsafe fn boolean(g: *mut c_void, v: u64) -> bool {
glue::rjs_to_boolean(g, v) != 0
}
unsafe fn seq(g: *mut c_void, v: u64) -> Result<Vec<Val>, ()> {
if v == UNDEF {
return Ok(Vec::new());
}
let f = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.array_from;
let arr = match call(g, f, UNDEF, &[v]) {
Ok(a) => Val::new(g, a),
Err(e) => {
glue::rjs_throw(g, e);
return Err(());
}
};
let n = uint(g, field(g, arr.v, "length")?.v, 0)?;
if n > 65536 {
throw_type_error(g, "WebGPU descriptor sequence is too large");
return Err(());
}
(0..n).map(|i| field(g, arr.v, &i.to_string())).collect()
}
unsafe fn try_handle(g: *mut c_void, v: u64, kind: Kind) -> Option<Handle> {
let cls = states()
.lock()
.unwrap()
.get(&(g as usize))
.and_then(|s| s.classes.as_ref())
.and_then(|c| c.hosts.get(&kind).copied())
.map(|c| c as capi::JSClassRef)?;
host_data::<Handle>(g, cls, v)
.filter(|h| h.kind == kind)
.map(|h| h.clone())
}
unsafe fn handle(g: *mut c_void, v: u64, kind: Kind) -> Result<Handle, ()> {
if let Some(h) = try_handle(g, v, kind) {
return Ok(h);
}
throw_type_error(g, "WebGPU object has the wrong interface or receiver");
Err(())
}
unsafe fn with_classes<T>(g: *mut c_void, f: impl FnOnce(&Classes) -> T) -> T {
f(states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap())
}
unsafe fn this(g: *mut c_void, cf: *mut c_void, kind: Kind) -> Result<Handle, ()> {
handle(g, cf_this(cf), kind)
}
unsafe fn client(g: *mut c_void, h: &Handle) -> Result<Arc<Client>, ()> {
let c = h.client.as_ref().unwrap().clone();
if let Err(e) = c.check() {
redjs::webapi::domexception::throw(g, "InvalidStateError", &e);
return Err(());
}
Ok(c)
}
unsafe fn owned(g: *mut c_void, v: u64, kind: Kind, c: &Arc<Client>) -> Result<Handle, ()> {
let h = handle(g, v, kind)?;
if h.client.as_ref().map(|x| x.id) != Some(c.id) {
throw_type_error(g, "WebGPU resource belongs to a different device");
return Err(());
}
Ok(h)
}
unsafe fn wrap(g: *mut c_void, kind: Kind, c: Option<Arc<Client>>, r: Resource) -> u64 {
let (cls, proto) = {
let s = states().lock().unwrap();
let cs = s[&(g as usize)].classes.as_ref().unwrap();
(cs.hosts[&kind] as capi::JSClassRef, cs.types[&kind].proto)
};
host_create(
g,
cls,
proto,
Handle {
kind,
client: c,
resource: r,
},
)
}
unsafe fn wrap_labeled(
g: *mut c_void,
kind: Kind,
c: Option<Arc<Client>>,
r: Resource,
label: &str,
) -> u64 {
let o = Val::new(g, wrap(g, kind, c, r));
set_label(g, o.v, label);
o.v
}
unsafe fn set_label(g: *mut c_void, obj: u64, label: &str) {
if label.is_empty() {
return;
}
let slot = with_classes(g, |c| c.s_label);
let s = Val::new(g, js_string(g, label));
glue::rjs_define(g, obj, slot as *mut c_void, s.v, 2);
}
unsafe fn object_base(g: *mut c_void, v: u64) -> Result<(), ()> {
let hosts: Vec<_> = with_classes(g, |c| c.hosts.values().copied().collect());
if hosts
.into_iter()
.any(|h| host_data::<Handle>(g, h as capi::JSClassRef, v).is_some())
{
return Ok(());
}
invalid(g, "WebGPU object has the wrong interface or receiver")
}
#[redjs::host_fn]
unsafe fn label_get(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
object_base(g, cf_this(cf))?;
let slot = with_classes(g, |c| c.s_label);
let v = get_a(g, cf_this(cf), slot as *mut c_void);
Ok(if v == UNDEF { js_string(g, "") } else { v })
})
}
#[redjs::host_fn]
unsafe fn label_set(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
object_base(g, cf_this(cf))?;
let s = Val::new(g, to_js_string(g, cf_arg(cf, 0))?);
let slot = with_classes(g, |c| c.s_label);
glue::rjs_define(g, cf_this(cf), slot as *mut c_void, s.v, 2);
Ok(UNDEF)
})
}
unsafe fn rejected_from_exception(g: *mut c_void) -> u64 {
let mut e = UNDEF;
if glue::rjs_exception_pending(g, &mut e) == 0 {
return UNDEF;
}
let e = Val::new(g, e);
redjs::webapi::domexception::rejected_with(g, e.v)
}
unsafe fn invalid(g: *mut c_void, msg: &str) -> Result<(), ()> {
throw_type_error(g, msg);
Err(())
}
// Canvas texture destruction closes JS write access while its drawing buffer
// remains readable by the presenter. Recorded commands must honor that logical
// lifetime even though the underlying native texture is still alive.
fn resource_alive(r: &Resource) -> bool {
match r {
Resource::Buffer(b) => !b.destroyed.load(Ordering::Acquire),
Resource::Texture(t) => !t.destroyed.load(Ordering::Acquire),
Resource::TextureView(v) => !v._owner.destroyed.load(Ordering::Acquire),
Resource::BindGroup(b) => b._resources.iter().all(resource_alive),
Resource::QuerySet(q) => !q.destroyed.load(Ordering::Acquire),
Resource::Bundle(b) => b.resources.iter().all(resource_alive),
_ => true,
}
}
unsafe fn validation(g: *mut c_void, c: &Arc<Client>, msg: &str) {
route_errors(
g,
c.id,
vec![backend::GpuError {
kind: "validation",
message: msg.into(),
}],
);
}
unsafe fn checked<T>(g: *mut c_void, c: &Arc<Client>, f: impl FnOnce() -> T) -> T {
let out = c.checked(f);
route_errors(g, c.id, c.take_errors());
out
}
unsafe fn error_object(g: *mut c_void, e: backend::GpuError) -> u64 {
let name = match e.kind {
"out-of-memory" => "GPUOutOfMemoryError",
"internal" => "GPUInternalError",
_ => "GPUValidationError",
};
let proto = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.error_protos[name];
let o = Val::new(g, new_object(g, proto));
define(g, o.v, "message", js_string(g, &e.message), 1 | 2);
o.v
}
unsafe fn route_errors(g: *mut c_void, id: u64, errors: Vec<backend::GpuError>) {
for e in errors {
let uncaptured = {
let mut ss = states().lock().unwrap();
let scopes = ss
.get_mut(&(g as usize))
.unwrap()
.scopes
.entry(id)
.or_default();
if let Some(scope) = scopes.iter_mut().rev().find(|x| x.filter == e.kind) {
if scope.error.is_none() {
scope.error = Some(e);
}
None
} else {
Some(e)
}
};
if let Some(e) = uncaptured {
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.ready
.push_back(Box::new(move |g| unsafe {
if let Some(target) = device_target(g, id) {
let error = Val::new(g, error_object(g, e));
let event = Val::new(
g,
redjs::webapi::events::new_trusted_event(g, "uncapturederror"),
);
define(g, event.v, "error", error.v, 1 | 2);
let proto = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.error_protos["GPUUncapturedErrorEvent"];
capi::JSObjectSetPrototype(
g,
event.v as usize as capi::JSObjectRef,
proto as usize as capi::JSValueRef,
);
redjs::webapi::events::dispatch(g, target.v, event.v);
}
}));
}
}
}
#[redjs::host_fn]
unsafe fn gpu_error_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let message = text(g, cf_arg(cf, 0), "")?;
let o = Val::new(g, ordinary_create(g, cf_new_target(cf), UNDEF));
define(g, o.v, "message", js_string(g, &message), 1 | 2);
Ok(o.v)
})
}
#[redjs::host_fn]
unsafe fn error_event_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let init = Val::new(g, cf_arg(cf, 1));
let error = field(g, init.v, "error")?;
if !is_cell(error.v) {
invalid(g, "GPUUncapturedErrorEvent requires an error")?;
}
let o = Val::new(
g,
ordinary_create(
g,
cf_new_target(cf),
redjs::webapi::util::state(g).event.proto,
),
);
redjs::webapi::events::init_event(g, o.v, cf_arg(cf, 0), init.v, false);
define(g, o.v, "error", error.v, 1 | 2);
Ok(o.v)
})
}
/// Promise completions own only protected values while their context is alive.
/// Workers carry Rust resources, never JS heap pointers; recycled addresses are
/// fenced by ContextId before enqueueing on the context pump.
unsafe fn async_op<T, F, C>(g: *mut c_void, roots: Vec<u64>, work: F, convert: C) -> u64
where
T: Send + 'static,
F: std::future::Future<Output = Result<T, String>> + Send + 'static,
C: FnOnce(*mut c_void, T) -> u64 + Send + 'static,
{
async_settle(g, roots, work, move |g, value| Ok(convert(g, value)))
}
unsafe fn async_settle<T, F, C>(g: *mut c_void, roots: Vec<u64>, work: F, convert: C) -> u64
where
T: Send + 'static,
F: std::future::Future<Output = Result<T, String>> + Send + 'static,
C: FnOnce(*mut c_void, T) -> Result<u64, u64> + Send + 'static,
{
static NEXT: AtomicU64 = AtomicU64::new(1);
let (mut resolve, mut reject, mut p) = (UNDEF, UNDEF, UNDEF);
if redjs::ffi::redjs_promise_create(g, &mut resolve, &mut reject, &mut p) != 0 {
return UNDEF;
}
for &v in roots.iter().chain([&resolve, &reject]) {
if is_cell(v) {
redjs::ffi::redjs_protect(g, v);
}
}
let n = NEXT.fetch_add(1, Ordering::Relaxed);
let id = redjs::context::id_of(g);
let address = g as usize;
states()
.lock()
.unwrap()
.get_mut(&address)
.unwrap()
.pending
.insert(
n,
Pending {
resolve,
reject,
roots,
},
);
let worker = std::thread::Builder::new()
.name("redjs-webgpu".into())
.spawn(move || {
let result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| pollster::block_on(work)))
.unwrap_or_else(|_| Err("Native WebGPU asynchronous operation failed".into()));
let mut ss = states().lock().unwrap();
if redjs::context::id_of(address as *mut c_void) != id {
return;
}
let Some(st) = ss.get_mut(&address) else {
return;
};
st.ready.push_back(Box::new(move |g| unsafe {
let pending = states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.and_then(|s| s.pending.remove(&n));
let Some(pending) = pending else {
return;
};
match result {
Ok(value) => {
match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
convert(g, value)
})) {
Ok(Ok(value)) => {
let value = Val::new(g, value);
let _ = call(g, pending.resolve, UNDEF, &[value.v]);
}
Ok(Err(reason)) => {
let reason = Val::new(g, reason);
let _ = call(g, pending.reject, UNDEF, &[reason.v]);
}
Err(_) => {
let err = Val::new(
g,
redjs::webapi::domexception::create(
g,
"OperationError",
"Native WebGPU completion failed",
),
);
let _ = call(g, pending.reject, UNDEF, &[err.v]);
}
}
}
Err(message) => {
let err = Val::new(
g,
redjs::webapi::domexception::create(g, "OperationError", &message),
);
let _ = call(g, pending.reject, UNDEF, &[err.v]);
}
}
for v in pending
.roots
.into_iter()
.chain([pending.resolve, pending.reject])
{
if is_cell(v) {
redjs::ffi::redjs_unprotect(g, v);
}
}
}));
drop(ss);
if let Some(id) = id {
redjs::web::wake(id);
}
});
if let Err(error) = worker {
let pending = states()
.lock()
.unwrap()
.get_mut(&address)
.unwrap()
.pending
.remove(&n)
.unwrap();
let e = Val::new(
g,
redjs::webapi::domexception::create(g, "OperationError", &error.to_string()),
);
let _ = call(g, pending.reject, UNDEF, &[e.v]);
for v in pending
.roots
.into_iter()
.chain([pending.resolve, pending.reject])
{
if is_cell(v) {
redjs::ffi::redjs_unprotect(g, v);
}
}
}
p
}
unsafe fn inflight(g: *mut c_void) -> bool {
states()
.lock()
.unwrap()
.get(&(g as usize))
.is_some_and(|s| !s.pending.is_empty())
}
unsafe fn ready(g: *mut c_void) -> bool {
states()
.lock()
.unwrap()
.get(&(g as usize))
.is_some_and(|s| {
!s.ready.is_empty()
|| s.clients.values().any(|r| {
r.client
.upgrade()
.is_some_and(|c| c.has_errors() || (!r.lost && c.context.loss().is_some()))
})
})
}
unsafe fn drain(g: *mut c_void) -> usize {
let tasks = states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.map(|s| std::mem::take(&mut s.ready))
.unwrap_or_default();
let mut n = tasks.len();
for task in tasks {
task(g);
redjs::web::checkpoint(g);
}
let clients: Vec<_> = states()
.lock()
.unwrap()
.get(&(g as usize))
.map(|s| {
s.clients
.values()
.filter_map(|r| r.client.upgrade())
.collect()
})
.unwrap_or_default();
for c in clients {
route_errors(g, c.id, c.take_errors());
}
let ids: Vec<_> = states()
.lock()
.unwrap()
.get(&(g as usize))
.map(|s| {
s.clients
.iter()
.filter_map(|(&id, r)| {
(!r.lost)
.then(|| r.client.upgrade())
.flatten()
.and_then(|c| c.context.loss().map(|l| (id, l)))
})
.collect()
})
.unwrap_or_default();
for (id, loss) in ids {
release_buffers(g, id);
canvas::device_destroyed(id);
if let Some(target) = device_target(g, id) {
resolve_loss(g, target.v, loss.reason, &loss.message);
} else if let Some(r) = states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.and_then(|s| s.clients.get_mut(&id))
{
r.lost = true;
}
n += 1;
}
n
}
#[redjs::host_fn]
unsafe fn request_adapter(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
this(g, cf, Kind::Gpu)?;
let o = Val::new(g, cf_arg(cf, 0));
let power = text(g, field(g, o.v, "powerPreference")?.v, "")?;
let power_preference = match power.as_str() {
"" => wgpu::PowerPreference::None,
"low-power" => wgpu::PowerPreference::LowPower,
"high-performance" => wgpu::PowerPreference::HighPerformance,
_ => {
invalid(g, "Invalid GPUPowerPreference")?;
unreachable!()
}
};
let fallback = boolean(g, field(g, o.v, "forceFallbackAdapter")?.v);
Ok(async_op(
g,
vec![],
async move {
backend::request_adapter(backend::AdapterOptions {
power_preference,
force_fallback_adapter: fallback,
})
.await
},
|g, a| match a {
Some(a) => wrap(g, Kind::Adapter, None, Resource::Adapter(Arc::new(a))),
None => NULL,
},
))
})
}
#[redjs::host_fn]
unsafe fn preferred_format(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
this(g, cf, Kind::Gpu)?;
Ok(js_string(g, "bgra8unorm"))
})
}
unsafe fn features_object(g: *mut c_void, features: wgpu::Features) -> u64 {
let names = feature_names()
.into_iter()
.filter(|(_, flag)| features.contains(*flag))
.map(|(name, _)| name)
.collect();
wrap(g, Kind::Features, None, Resource::Features(names))
}
unsafe fn feature_flags(g: *mut c_void, cf: *mut c_void) -> Result<Arc<[&'static str]>, ()> {
let h = match try_handle(g, cf_this(cf), Kind::LanguageFeatures) {
Some(h) => h,
None => this(g, cf, Kind::Features)?,
};
let Resource::Features(f) = h.resource else {
unreachable!()
};
Ok(f)
}
#[redjs::host_fn]
unsafe fn feature_size(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || Ok(enc_f64(feature_flags(g, cf)?.len() as f64)))
}
#[redjs::host_fn]
unsafe fn feature_has(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let f = feature_flags(g, cf)?;
let name = text(g, cf_arg(cf, 0), "")?;
Ok(enc_bool(f.iter().any(|n| *n == name)))
})
}
unsafe fn feature_iterator(g: *mut c_void, cf: *mut c_void, entries: bool) -> Result<u64, ()> {
let f = feature_flags(g, cf)?;
let a = Val::new(g, new_array(g));
for (i, name) in f.iter().copied().enumerate() {
let value = Val::new(g, js_string(g, name));
if entries {
let pair = Val::new(g, new_array(g));
set_i(g, pair.v, 0, value.v);
set_i(g, pair.v, 1, value.v);
set_i(g, a.v, i as u32, pair.v);
} else {
set_i(g, a.v, i as u32, value.v);
}
}
let values = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.array_values;
call(g, values, a.v, &[]).map_err(|e| {
glue::rjs_throw(g, e);
})
}
#[redjs::host_fn]
unsafe fn feature_values(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || feature_iterator(g, cf, false))
}
#[redjs::host_fn]
unsafe fn feature_entries(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || feature_iterator(g, cf, true))
}
#[redjs::host_fn]
unsafe fn feature_each(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let f = feature_flags(g, cf)?;
let cb = cf_arg(cf, 0);
if glue::rjs_kind(g, cb) != 9 {
invalid(g, "GPUSupportedFeatures.forEach requires a callback")?;
}
for name in f.iter() {
let s = Val::new(g, js_string(g, name));
call(g, cb, cf_arg(cf, 1), &[s.v, s.v, cf_this(cf)]).map_err(|e| {
glue::rjs_throw(g, e);
})?;
}
Ok(UNDEF)
})
}
unsafe fn cached(g: *mut c_void, obj: u64, slot: usize, build: impl FnOnce() -> u64) -> u64 {
let old = get_a(g, obj, slot as *mut c_void);
if old != UNDEF {
return old;
}
let v = Val::new(g, build());
glue::rjs_define(g, obj, slot as *mut c_void, v.v, 1 | 2);
v.v
}
unsafe fn plain(g: *mut c_void, kind: Kind) -> u64 {
let proto = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.types[&kind]
.proto;
new_object(g, proto)
}
// Capability advertising follows implemented APIs. Compressed texture, f16 and
// subgroup surfaces need per-client shader virtualization on a shared device.
fn feature_names() -> [(&'static str, wgpu::Features); 2] {
[
("core-features-and-limits", wgpu::Features::empty()),
("timestamp-query", wgpu::Features::TIMESTAMP_QUERY),
]
}
#[redjs::host_fn]
unsafe fn adapter_features(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Adapter)?;
let Resource::Adapter(a) = h.resource else {
unreachable!()
};
let slot = with_classes(g, |c| c.s_features);
Ok(cached(g, cf_this(cf), slot, || {
features_object(g, a.features())
}))
})
}
#[redjs::host_fn]
unsafe fn wgsl_language_features(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
this(g, cf, Kind::Gpu)?;
let slot = with_classes(g, |c| c.s_language);
Ok(cached(g, cf_this(cf), slot, || {
let names = wgpu::naga::front::wgsl::ImplementedLanguageExtension::all()
.iter()
.map(|e| e.to_ident())
.collect();
wrap(g, Kind::LanguageFeatures, None, Resource::Features(names))
}))
})
}
#[redjs::host_fn]
unsafe fn device_features(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Device)?;
let slot = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.s_features;
Ok(cached(g, cf_this(cf), slot, || {
features_object(g, h.client.unwrap().features)
}))
})
}
macro_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}};}
// With core-features-and-limits the per-stage storage limits are the
// vertex/fragment ones; wgpu has no separate fields for them.
fn stage_limit_aliases(l: &wgpu::Limits) -> [(&'static str, u32); 4] {
[
(
"maxStorageBuffersInVertexStage",
l.max_storage_buffers_per_shader_stage,
),
(
"maxStorageBuffersInFragmentStage",
l.max_storage_buffers_per_shader_stage,
),
(
"maxStorageTexturesInVertexStage",
l.max_storage_textures_per_shader_stage,
),
(
"maxStorageTexturesInFragmentStage",
l.max_storage_textures_per_shader_stage,
),
]
}
unsafe fn limits_object(g: *mut c_void, l: &wgpu::Limits) -> u64 {
let o = Val::new(g, plain(g, Kind::Limits));
macro_rules! write {($($js:ident=>$rust:ident),*)=>{$(define(g,o.v,stringify!($js),enc_f64(l.$rust as f64),1|2);)*};}
limits_fields!(write);
for (name, value) in stage_limit_aliases(l) {
define(g, o.v, name, enc_f64(value as f64), 1 | 2);
}
o.v
}
#[redjs::host_fn]
unsafe fn adapter_limits(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Adapter)?;
let Resource::Adapter(a) = h.resource else {
unreachable!()
};
let slot = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.s_limits;
Ok(cached(g, cf_this(cf), slot, || {
limits_object(g, &a.limits())
}))
})
}
#[redjs::host_fn]
unsafe fn device_limits(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Device)?;
let slot = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.s_limits;
Ok(cached(g, cf_this(cf), slot, || {
limits_object(g, &h.client.unwrap().limits)
}))
})
}
#[redjs::host_fn]
unsafe fn adapter_info(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Adapter)?;
let Resource::Adapter(a) = h.resource else {
unreachable!()
};
let slot = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.s_info;
Ok(cached(g, cf_this(cf), slot, || {
info_object(g, a.raw.get_info())
}))
})
}
#[redjs::host_fn]
unsafe fn device_adapter_info(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Device)?;
let adapter = h.client.unwrap().context.adapter.clone();
let slot = with_classes(g, |c| c.s_info);
Ok(cached(g, cf_this(cf), slot, || {
info_object(g, adapter.get_info())
}))
})
}
unsafe fn info_object(g: *mut c_void, i: wgpu::AdapterInfo) -> u64 {
let o = Val::new(g, plain(g, Kind::AdapterInfo));
for (k, v) in [
("vendor", format!("{:x}", i.vendor)),
("architecture", String::new()),
("device", format!("{:x}", i.device)),
("description", i.name),
] {
define(g, o.v, k, js_string(g, &v), 1 | 2);
}
// The spec's values while "subgroups" is not an exposed feature.
for (k, v) in [("subgroupMinSize", 4), ("subgroupMaxSize", 128)] {
define(g, o.v, k, enc_f64(v as f64), 1 | 2);
}
define(
g,
o.v,
"isFallbackAdapter",
enc_bool(i.device_type == wgpu::DeviceType::Cpu),
1 | 2,
);
o.v
}
#[redjs::host_fn]
unsafe fn request_device(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Adapter)?;
let Resource::Adapter(a) = h.resource else {
unreachable!()
};
let d = Val::new(g, cf_arg(cf, 0));
let label = text(g, field(g, d.v, "label")?.v, "")?;
let mut features = wgpu::Features::empty();
let available = a.features();
for v in seq(g, field(g, d.v, "requiredFeatures")?.v)? {
let name = text(g, v.v, "")?;
let Some((_, flag)) = feature_names()
.into_iter()
.find(|(n, flag)| *n == name && available.contains(*flag))
else {
return Ok(redjs::webapi::domexception::rejected(
g,
"NotSupportedError",
&format!("Unsupported WebGPU feature: {name}"),
));
};
features |= flag;
}
let l = field(g, d.v, "requiredLimits")?;
let adapter_limits = a.limits();
let mut limits = wgpu::Limits {
max_immediate_size: 64.min(adapter_limits.max_immediate_size),
..Default::default()
};
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");})?;})*};}
limits_fields!(read);
for (name, available) in stage_limit_aliases(&adapter_limits) {
let v = field(g, l.v, name)?;
if v.v != UNDEF && num(g, v.v, 0)? > available as u64 {
return Ok(redjs::webapi::domexception::rejected(
g,
"OperationError",
&format!("Unsupported requiredLimits: {name}"),
));
}
}
let queue = field(g, d.v, "defaultQueue")?;
let queue_label = text(g, field(g, queue.v, "label")?.v, "")?;
let client_limits = limits.clone();
Ok(async_op(
g,
vec![],
async move { a.request_device(features, limits).await },
move |g, context| {
let device = Val::new(
g,
make_device(
g,
Client::new_with_capabilities(context, features, client_limits),
),
);
set_label(g, device.v, &label);
set_label(g, get(g, device.v, "queue"), &queue_label);
device.v
},
))
})
}
unsafe fn make_device(g: *mut c_void, c: Arc<Client>) -> u64 {
prune_clients(g);
let o = Val::new(g, wrap(g, Kind::Device, Some(c.clone()), Resource::Device));
let queue = Val::new(g, wrap(g, Kind::Queue, Some(c.clone()), Resource::Queue));
define(g, o.v, "queue", queue.v, 1 | 2);
let (mut res, mut rej, mut p) = (UNDEF, UNDEF, UNDEF);
redjs::ffi::redjs_promise_create(g, &mut res, &mut rej, &mut p);
let pr = Val::new(g, p);
let rr = Val::new(g, res);
let (sl, sr) = {
let s = states().lock().unwrap();
let c = s[&(g as usize)].classes.as_ref().unwrap();
(c.s_lost, c.s_resolve_lost)
};
glue::rjs_define(g, o.v, sl as *mut c_void, pr.v, 1 | 2);
glue::rjs_define(g, pr.v, sl as *mut c_void, o.v, 1 | 2);
glue::rjs_define(g, o.v, sr as *mut c_void, rr.v, 1 | 2);
let weak = weak_ref(g, o.v);
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.clients
.insert(
c.id,
ClientRef {
weak,
client: Arc::downgrade(&c),
buffers: Vec::new(),
lost: false,
},
);
o.v
}
#[redjs::host_fn]
unsafe fn lost(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
this(g, cf, Kind::Device)?;
let sl = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.s_lost;
Ok(get_a(g, cf_this(cf), sl as *mut c_void))
})
}
unsafe fn prune_clients(g: *mut c_void) {
let dead = {
let mut s = states().lock().unwrap();
let s = s.get_mut(&(g as usize)).unwrap();
let ids: Vec<_> = s
.clients
.iter()
.filter_map(|(&id, r)| (r.client.strong_count() == 0).then_some(id))
.collect();
ids.into_iter()
.map(|id| {
s.scopes.remove(&id);
s.clients.remove(&id).unwrap()
})
.collect::<Vec<_>>()
};
for r in dead {
for v in r.buffers.into_iter().chain([r.weak]) {
redjs::ffi::redjs_unprotect(g, v);
}
}
}
unsafe fn weak_ref(g: *mut c_void, obj: u64) -> u64 {
let ctor = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.weak_ctor;
let mut out = UNDEF;
if glue::rjs_construct(g, ctor, &obj, 1, &mut out) != 0 {
panic!("Intrinsic WeakRef construction failed");
}
redjs::ffi::redjs_protect(g, out);
out
}
unsafe fn deref(g: *mut c_void, weak: u64) -> Val {
let f = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.weak_deref;
Val::new(g, call(g, f, weak, &[]).unwrap_or(UNDEF))
}
unsafe fn device_target(g: *mut c_void, id: u64) -> Option<Val> {
let weak = states()
.lock()
.unwrap()
.get(&(g as usize))?
.clients
.get(&id)?
.weak;
let v = deref(g, weak);
is_cell(v.v).then_some(v)
}
unsafe fn track_buffer_object(g: *mut c_void, c: &Arc<Client>, obj: u64) {
let weak = weak_ref(g, obj);
let old = {
let mut s = states().lock().unwrap();
let r = s
.get_mut(&(g as usize))
.unwrap()
.clients
.get_mut(&c.id)
.unwrap();
r.buffers.push(weak);
if r.buffers.len() % 64 == 0 {
std::mem::take(&mut r.buffers)
} else {
Vec::new()
}
};
let mut live = Vec::new();
for w in old {
if is_cell(deref(g, w).v) {
live.push(w)
} else {
redjs::ffi::redjs_unprotect(g, w);
}
}
if !live.is_empty() {
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.clients
.get_mut(&c.id)
.unwrap()
.buffers
.extend(live);
}
}
unsafe fn release_buffers(g: *mut c_void, id: u64) {
let buffers = states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.and_then(|s| s.clients.get_mut(&id))
.map(|r| std::mem::take(&mut r.buffers))
.unwrap_or_default();
for w in buffers {
let o = deref(g, w);
if is_cell(o.v) {
buffer::release_on_device_destroy(g, o.v);
}
redjs::ffi::redjs_unprotect(g, w);
}
}
unsafe fn resolve_loss(g: *mut c_void, target: u64, reason: &str, message: &str) {
let sr = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.s_resolve_lost;
let res = Val::new(g, get_a(g, target, sr as *mut c_void));
let info = Val::new(g, plain(g, Kind::LostInfo));
define(g, info.v, "reason", js_string(g, reason), 1 | 2);
define(g, info.v, "message", js_string(g, message), 1 | 2);
let _ = call(g, res.v, UNDEF, &[info.v]);
if let Ok(h) = handle(g, target, Kind::Device) {
let id = h.client.unwrap().id;
if let Some(r) = states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.and_then(|s| s.clients.get_mut(&id))
{
r.lost = true;
}
}
}
#[redjs::host_fn]
unsafe fn destroy(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Device)?;
let c = h.client.unwrap();
release_buffers(g, c.id);
c.destroy();
canvas::device_destroyed(c.id);
resolve_loss(
g,
cf_this(cf),
"destroyed",
"Logical WebGPU device was destroyed",
);
Ok(UNDEF)
})
}
#[redjs::host_fn]
unsafe fn uncaptured_handler_get(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
this(g, cf, Kind::Device)?;
let slot = with_classes(g, |c| c.s_handlers);
let v = get_a(g, cf_this(cf), slot as *mut c_void);
Ok(if v == UNDEF { NULL } else { v })
})
}
#[redjs::host_fn]
unsafe fn uncaptured_handler_set(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
this(g, cf, Kind::Device)?;
let v = cf_arg(cf, 0);
let v = if redjs::webapi::events::is_callable(g, v) {
v
} else {
NULL
};
let slot = with_classes(g, |c| c.s_handlers);
glue::rjs_define(g, cf_this(cf), slot as *mut c_void, v, 2);
Ok(UNDEF)
})
}
unsafe fn pipeline_error(g: *mut c_void, reason: &str, message: &str) -> u64 {
let (proto, slot) = with_classes(g, |c| (c.pipeline_error_proto, c.s_reason));
let e = Val::new(
g,
redjs::webapi::domexception::create(g, "GPUPipelineError", message),
);
capi::JSObjectSetPrototype(
g,
e.v as usize as capi::JSObjectRef,
proto as usize as capi::JSValueRef,
);
let r = Val::new(g, js_string(g, reason));
glue::rjs_define(g, e.v, slot as *mut c_void, r.v, 1 | 2);
e.v
}
#[redjs::host_fn]
unsafe fn pipeline_error_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let message = text(g, cf_arg(cf, 0), "")?;
let options = Val::new(g, cf_arg(cf, 1));
if !is_cell(options.v) {
invalid(g, "GPUPipelineError requires a GPUPipelineErrorInit")?;
}
let reason = field(g, options.v, "reason")?;
if reason.v == UNDEF {
invalid(g, "GPUPipelineErrorInit.reason is required")?;
}
let reason = text(g, reason.v, "")?;
if reason != "validation" && reason != "internal" {
invalid(g, "Invalid GPUPipelineErrorReason")?;
}
let e = Val::new(g, pipeline_error(g, &reason, &message));
let target = cf_new_target(cf);
if is_cell(target) {
let proto = get(g, target, "prototype");
if is_cell(proto) {
capi::JSObjectSetPrototype(
g,
e.v as usize as capi::JSObjectRef,
proto as usize as capi::JSValueRef,
);
}
}
Ok(e.v)
})
}
#[redjs::host_fn]
unsafe fn pipeline_error_reason(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let slot = with_classes(g, |c| c.s_reason);
let this = cf_this(cf);
let v = if is_cell(this) {
get_a(g, this, slot as *mut c_void)
} else {
UNDEF
};
if v == UNDEF {
invalid(
g,
"GPUPipelineError.reason called on an incompatible receiver",
)?;
}
Ok(v)
})
}
#[redjs::host_fn]
unsafe fn push_scope(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Device)?;
let c = h.client.as_ref().unwrap();
route_errors(g, c.id, c.take_errors());
let filter = text(g, cf_arg(cf, 0), "")?;
if !["validation", "out-of-memory", "internal"].contains(&filter.as_str()) {
invalid(g, "Invalid GPUErrorFilter")?;
}
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.scopes
.entry(h.client.unwrap().id)
.or_default()
.push(Scope {
filter,
error: None,
});
Ok(UNDEF)
})
}
#[redjs::host_fn]
unsafe fn pop_scope(g: *mut c_void, cf: *mut c_void) -> u64 {
run(g, || {
let h = this(g, cf, Kind::Device)?;
let scope = states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.scopes
.entry(h.client.unwrap().id)
.or_default()
.pop();
let Some(scope) = scope else {
return Ok(redjs::webapi::domexception::rejected(
g,
"OperationError",
"No WebGPU error scope to pop",
));
};
let value = Val::new(g, scope.error.map_or(NULL, |e| error_object(g, e)));
Ok(resolved_promise(g, value.v))
})
}
/// No Rust unwind is allowed to cross a JSC host callback. Normal validation
/// errors are captured by wgpu scopes; internal bugs still return a JS error.
unsafe fn run(g: *mut c_void, f: impl FnOnce() -> Result<u64, ()>) -> u64 {
match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) {
Ok(Ok(v)) => v,
Ok(Err(())) => UNDEF,
Err(payload) => {
let reason = payload
.downcast_ref::<String>()
.map(String::as_str)
.or_else(|| payload.downcast_ref::<&str>().copied())
.unwrap_or("an internal error");
let reason = reason.split_whitespace().collect::<Vec<_>>().join(" ");
redjs::webapi::domexception::throw(
g,
"OperationError",
&format!("Native WebGPU operation failed: {reason}"),
)
}
}
}
unsafe extern "C" fn finalize_handle(obj: capi::JSObjectRef) {
let p = capi::JSObjectGetPrivate(obj);
if !p.is_null() {
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
drop(Box::from_raw(p as *mut Handle))
}));
}
}
unsafe fn make_gpu_host_class(name: &str) -> capi::JSClassRef {
let name = std::ffi::CString::new(name).unwrap();
let mut d = capi::JSClassDefinition::empty();
d.class_name = name.as_ptr();
d.finalize = Some(finalize_handle);
capi::JSClassCreate(&d)
}
pub(crate) unsafe fn install(g: *mut c_void) {
states()
.lock()
.unwrap()
.insert(g as usize, State::default());
let global = glue::rjs_global(g);
let array = Val::new(g, get(g, global, "Array"));
let from = Val::new(g, get(g, array.v, "from"));
redjs::ffi::redjs_protect(g, from.v);
let weak_ctor = Val::new(g, get(g, global, "WeakRef"));
let weak_proto = field(g, weak_ctor.v, "prototype").unwrap();
let weak_deref = field(g, weak_proto.v, "deref").unwrap();
for v in [weak_ctor.v, weak_deref.v] {
redjs::ffi::redjs_protect(g, v);
}
let ap = field(g, array.v, "prototype").unwrap();
let array_values = field(g, ap.v, "values").unwrap();
redjs::ffi::redjs_protect(g, array_values.v);
let classes = Classes {
array_values: array_values.v,
s_features: atom_priv(g, "webgpu.features") as usize,
s_limits: atom_priv(g, "webgpu.limits") as usize,
s_info: atom_priv(g, "webgpu.info") as usize,
weak_ctor: weak_ctor.v,
weak_deref: weak_deref.v,
error_protos: HashMap::new(),
hosts: HashMap::new(),
types: HashMap::new(),
array_from: from.v,
s_gpu_canvas: atom_priv(g, "webgpu.canvas") as usize,
s_gpu_device: atom_priv(g, "webgpu.canvasDevice") as usize,
s_gpu_texture: atom_priv(g, "webgpu.canvasTexture") as usize,
s_ranges: atom_priv(g, "webgpu.ranges") as usize,
s_lost: atom_priv(g, "webgpu.lost") as usize,
s_resolve_lost: atom_priv(g, "webgpu.resolveLost") as usize,
s_label: atom_priv(g, "webgpu.label") as usize,
s_handlers: atom_priv(g, "webgpu.onuncapturederror") as usize,
s_language: atom_priv(g, "webgpu.wgslLanguageFeatures") as usize,
s_reason: atom_priv(g, "webgpu.pipelineErrorReason") as usize,
pipeline_error_proto: 0,
};
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.classes = Some(classes);
class(
g,
Kind::Gpu,
"GPU",
&[
("requestAdapter", 0, request_adapter),
("getPreferredCanvasFormat", 0, preferred_format),
],
&[("wgslLanguageFeatures", wgsl_language_features)],
);
class(
g,
Kind::Adapter,
"GPUAdapter",
&[("requestDevice", 0, request_device)],
&[
("features", adapter_features),
("limits", adapter_limits),
("info", adapter_info),
],
);
class(
g,
Kind::Device,
"GPUDevice",
&[
("destroy", 0, destroy),
("pushErrorScope", 1, push_scope),
("popErrorScope", 0, pop_scope),
],
&[
("features", device_features),
("limits", device_limits),
("lost", lost),
("adapterInfo", device_adapter_info),
],
);
let device_proto = with_classes(g, |c| c.types[&Kind::Device].proto);
let a = atom(g, "onuncapturederror");
glue::rjs_define_accessor(
g,
device_proto,
a,
make_fn(g, "get onuncapturederror", 0, uncaptured_handler_get),
make_fn(g, "set onuncapturederror", 1, uncaptured_handler_set),
2,
);
glue::rjs_atom_free(g, a);
class(g, Kind::Queue, "GPUQueue", &[], &[]);
for (kind, name) in [
(Kind::Features, "GPUSupportedFeatures"),
(Kind::LanguageFeatures, "WGSLLanguageFeatures"),
] {
class(
g,
kind,
name,
&[
("has", 1, feature_has),
("keys", 0, feature_values),
("values", 0, feature_values),
("entries", 0, feature_entries),
("forEach", 1, feature_each),
],
&[("size", feature_size)],
);
let proto = with_classes(g, |c| c.types[&kind].proto);
let iter = glue::rjs_atom_iterator(g);
glue::rjs_define(g, proto, iter, make_fn(g, "values", 0, feature_values), 2);
glue::rjs_atom_free(g, iter);
}
class(g, Kind::Limits, "GPUSupportedLimits", &[], &[]);
class(g, Kind::AdapterInfo, "GPUAdapterInfo", &[], &[]);
class(g, Kind::LostInfo, "GPUDeviceLostInfo", &[], &[]);
let base = define_class(
g,
&ClassSpec {
name: "GPUError",
arity: 0,
construct: None,
parent_proto: 0,
methods: &[],
getters: &[],
accessors: &[],
},
);
for name in [
"GPUValidationError",
"GPUOutOfMemoryError",
"GPUInternalError",
] {
let c = define_class(
g,
&ClassSpec {
name,
arity: 1,
construct: Some(gpu_error_construct),
parent_proto: base.proto,
methods: &[],
getters: &[],
accessors: &[],
},
);
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.classes
.as_mut()
.unwrap()
.error_protos
.insert(name, c.proto);
}
let event_class = define_class(
g,
&ClassSpec {
name: "GPUUncapturedErrorEvent",
arity: 2,
construct: Some(error_event_construct),
parent_proto: redjs::webapi::util::state(g).event.proto,
methods: &[],
getters: &[],
accessors: &[],
},
);
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.classes
.as_mut()
.unwrap()
.error_protos
.insert("GPUUncapturedErrorEvent", event_class.proto);
let dom_exception = Val::new(g, get(g, global, "DOMException"));
let dom_proto = field(g, dom_exception.v, "prototype").unwrap();
let pipeline_error_class = define_class(
g,
&ClassSpec {
name: "GPUPipelineError",
arity: 2,
construct: Some(pipeline_error_construct),
parent_proto: dom_proto.v,
methods: &[],
getters: &[("reason", pipeline_error_reason)],
accessors: &[],
},
);
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.classes
.as_mut()
.unwrap()
.pipeline_error_proto = pipeline_error_class.proto;
buffer::install(g);
compute::install(g);
texture::install(g);
query::install(g);
bundle::install(g);
canvas::install(g);
let nav = Val::new(g, get(g, global, "navigator"));
let gpu = wrap(g, Kind::Gpu, None, Resource::Gpu);
define(g, nav.v, "gpu", gpu, 1 | 2);
redjs::web::register_pump_source(redjs::web::PumpSource {
inflight,
ready,
drain,
});
}
unsafe fn class(
g: *mut c_void,
kind: Kind,
name: &str,
methods: &[(&str, u32, HostFn)],
getters: &[(&str, HostFn)],
) {
let host = make_gpu_host_class(name) as usize;
let parent = if kind == Kind::Device {
redjs::webapi::util::state(g).event_target.proto
} else {
0
};
let object_base = !matches!(
kind,
Kind::Gpu
| Kind::Canvas
| Kind::Adapter
| Kind::Features
| Kind::LanguageFeatures
| Kind::Limits
| Kind::AdapterInfo
| Kind::LostInfo
);
let label: &[(&str, HostFn, HostFn)] = &[("label", label_get, label_set)];
let c = define_class(
g,
&ClassSpec {
name,
arity: 0,
construct: None,
parent_proto: parent,
methods,
getters,
accessors: if object_base { label } else { &[] },
},
);
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.classes
.as_mut()
.unwrap()
.hosts
.insert(kind, host);
states()
.lock()
.unwrap()
.get_mut(&(g as usize))
.unwrap()
.classes
.as_mut()
.unwrap()
.types
.insert(kind, c);
}
unsafe fn method(g: *mut c_void, kind: Kind, name: &str, arity: u32, f: HostFn) {
let proto = states().lock().unwrap()[&(g as usize)]
.classes
.as_ref()
.unwrap()
.types[&kind]
.proto;
define(g, proto, name, make_fn(g, name, arity, f), 2);
}
unsafe fn constants(g: *mut c_void, name: &str, values: &[(&str, u32)]) {
let o = Val::new(g, new_object(g, UNDEF));
for &(n, v) in values {
define(g, o.v, n, enc_f64(v as f64), 1 | 2 | 4);
}
define(g, glue::rjs_global(g), name, o.v, 1 | 2);
}
pub(crate) fn forget(gone: redjs::context::Gone) {
canvas::forget(gone);
let s = states().lock().unwrap().remove(&gone.key);
if let Some(s) = s {
for r in s.clients.values() {
if let Some(c) = r.client.upgrade() {
c.destroy();
}
}
if let Some(c) = s.classes {
unsafe {
for host in c.hosts.into_values() {
capi::JSClassRelease(host as capi::JSClassRef);
}
}
}
}
}