// Copyright 2018-2025 the Deno authors. MIT license. use std::cell::RefCell; use std::sync::Arc; use deno_core::_ops::make_cppgc_object; use deno_core::cppgc::Ptr; use deno_core::op2; use deno_core::v8; use deno_core::GarbageCollected; use deno_core::WebIDL; use deno_error::JsErrorBox; use wgpu_types::SurfaceStatus; use crate::device::GPUDevice; use crate::error::GPUGenericError; use crate::texture::GPUTexture; use crate::texture::GPUTextureFormat; use crate::webidl::GPUTextureUsageFlags; #[derive(Debug, thiserror::Error, deno_error::JsError)] pub enum SurfaceError { #[class("DOMExceptionInvalidStateError")] #[error("Context is not configured")] UnconfiguredContext, #[class(generic)] #[error("Invalid Surface Status")] InvalidStatus, #[class(generic)] #[error(transparent)] Surface(#[from] wgpu_core::present::SurfaceError), } pub struct Configuration { pub device: Ptr, pub usage: GPUTextureUsageFlags, pub format: GPUTextureFormat, pub surface_config: wgpu_types::SurfaceConfiguration>, } pub struct GPUCanvasContext { pub wgpu_surface: Arc, pub width: RefCell, pub height: RefCell, pub config: RefCell>, pub texture: RefCell>>, pub canvas: v8::Global, } impl GarbageCollected for GPUCanvasContext { fn get_name(&self) -> &'static std::ffi::CStr { c"GPUCanvasContext" } } #[op2] impl GPUCanvasContext { #[constructor] #[cppgc] fn constructor(_: bool) -> Result { Err(GPUGenericError::InvalidConstructor) } #[getter] #[global] fn canvas(&self) -> v8::Global { self.canvas.clone() } #[reentrant] #[undefined] fn configure( &self, #[webidl] configuration: GPUCanvasConfiguration, ) -> Result<(), JsErrorBox> { if configuration .usage .0 .contains(wgpu_types::TextureUsages::TRANSIENT_ATTACHMENT) { return Err(JsErrorBox::type_error( "`GPUCanvasConfiguration.usage` must not include `TRANSIENT_ATTACHMENT`", )); } let format = configuration.format.into(); let conf = wgpu_types::SurfaceConfiguration { usage: configuration.usage.into(), format, color_space: wgpu_types::SurfaceColorSpace::Srgb, width: *self.width.borrow(), height: *self.height.borrow(), present_mode: configuration .present_mode .map(Into::into) .unwrap_or_default(), alpha_mode: configuration.alpha_mode.into(), view_formats: configuration .view_formats .into_iter() .map(Into::into) .collect(), desired_maximum_frame_latency: 2, }; let device = configuration.device; let result = self.wgpu_surface.configure(&device.wgpu_device, &conf); device.error_handler.push_error(result.err()); self.config.borrow_mut().replace(Configuration { device, usage: configuration.usage, format: configuration.format, surface_config: conf, }); Ok(()) } #[fast] #[undefined] fn unconfigure(&self) { *self.config.borrow_mut() = None; } #[global] fn get_current_texture( &self, scope: &mut v8::HandleScope, ) -> Result, SurfaceError> { let config = self.config.borrow(); let Some(config) = config.as_ref() else { return Err(SurfaceError::UnconfiguredContext); }; { if let Some(obj) = self.texture.borrow().as_ref() { return Ok(obj.clone()); } } let output = self.wgpu_surface.get_current_texture()?; match output.status { SurfaceStatus::Good | SurfaceStatus::Suboptimal => { let texture = GPUTexture { wgpu_texture: output.texture.unwrap(), default_view: Default::default(), dimension: crate::texture::GPUTextureDimension::D2, format: config.format, usage: config.usage, }; let obj = make_cppgc_object(scope, texture); let obj = v8::Global::new(scope, obj); *self.texture.borrow_mut() = Some(obj.clone()); Ok(obj) } _ => Err(SurfaceError::InvalidStatus), } } } impl GPUCanvasContext { pub fn present(&self) -> Result<(), SurfaceError> { let config = self.config.borrow(); if config.is_none() { return Err(SurfaceError::UnconfiguredContext); }; self.wgpu_surface.present()?; // next `get_current_texture` call would get a new texture *self.texture.borrow_mut() = None; Ok(()) } pub fn resize_configure(&self, width: u32, height: u32) { self.width.replace(width); self.height.replace(height); let mut config = self.config.borrow_mut(); let Some(config) = &mut *config else { return; }; config.surface_config.width = width; config.surface_config.height = height; let result = self .wgpu_surface .configure(&config.device.wgpu_device, &config.surface_config); config.device.error_handler.push_error(result.err()); } } #[derive(WebIDL)] #[webidl(dictionary)] struct GPUCanvasConfiguration { device: Ptr, format: GPUTextureFormat, #[webidl(default = GPUTextureUsageFlags(wgpu_types::TextureUsages::RENDER_ATTACHMENT))] usage: GPUTextureUsageFlags, #[webidl(default = GPUCanvasAlphaMode::Opaque)] alpha_mode: GPUCanvasAlphaMode, // Extended from spec present_mode: Option, #[webidl(default = vec![])] view_formats: Vec, } #[derive(WebIDL)] #[webidl(enum)] enum GPUCanvasAlphaMode { Opaque, Premultiplied, } impl From for wgpu_types::CompositeAlphaMode { fn from(value: GPUCanvasAlphaMode) -> Self { match value { GPUCanvasAlphaMode::Opaque => Self::Opaque, GPUCanvasAlphaMode::Premultiplied => Self::PreMultiplied, } } } // Extended from spec #[derive(WebIDL)] #[webidl(enum)] enum GPUPresentMode { #[webidl(rename = "autoVsync")] AutoVsync, #[webidl(rename = "autoNoVsync")] AutoNoVsync, #[webidl(rename = "fifo")] Fifo, #[webidl(rename = "fifoRelaxed")] FifoRelaxed, #[webidl(rename = "immediate")] Immediate, #[webidl(rename = "mailbox")] Mailbox, } impl From for wgpu_types::PresentMode { fn from(value: GPUPresentMode) -> Self { match value { GPUPresentMode::AutoVsync => Self::AutoVsync, GPUPresentMode::AutoNoVsync => Self::AutoNoVsync, GPUPresentMode::Fifo => Self::Fifo, GPUPresentMode::FifoRelaxed => Self::FifoRelaxed, GPUPresentMode::Immediate => Self::Immediate, GPUPresentMode::Mailbox => Self::Mailbox, } } }