| /* This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ |
| |
| // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl |
| use std::cell::Cell; |
| |
| use canvas_traits::webgl::{ |
| GlType, InternalFormatIntVec, WebGLCommand, WebGLError, WebGLRenderbufferId, WebGLResult, |
| WebGLVersion, webgl_channel, |
| }; |
| use dom_struct::dom_struct; |
| |
| use crate::dom::bindings::codegen::Bindings::EXTColorBufferHalfFloatBinding::EXTColorBufferHalfFloatConstants; |
| use crate::dom::bindings::codegen::Bindings::WEBGLColorBufferFloatBinding::WEBGLColorBufferFloatConstants; |
| use crate::dom::bindings::codegen::Bindings::WebGL2RenderingContextBinding::WebGL2RenderingContextConstants as constants; |
| use crate::dom::bindings::inheritance::Castable; |
| use crate::dom::bindings::reflector::{DomGlobal, reflect_dom_object}; |
| use crate::dom::bindings::root::{DomRoot, MutNullableDom}; |
| use crate::dom::webgl::webglframebuffer::WebGLFramebuffer; |
| use crate::dom::webgl::webglobject::WebGLObject; |
| use crate::dom::webgl::webglrenderingcontext::{Operation, WebGLRenderingContext}; |
| use crate::script_runtime::CanGc; |
| |
| #[dom_struct] |
| pub(crate) struct WebGLRenderbuffer { |
| webgl_object: WebGLObject, |
| #[no_trace] |
| id: WebGLRenderbufferId, |
| ever_bound: Cell<bool>, |
| is_deleted: Cell<bool>, |
| size: Cell<Option<(i32, i32)>>, |
| internal_format: Cell<Option<u32>>, |
| is_initialized: Cell<bool>, |
| attached_framebuffer: MutNullableDom<WebGLFramebuffer>, |
| } |
| |
| impl WebGLRenderbuffer { |
| fn new_inherited(context: &WebGLRenderingContext, id: WebGLRenderbufferId) -> Self { |
| Self { |
| webgl_object: WebGLObject::new_inherited(context), |
| id, |
| ever_bound: Cell::new(false), |
| is_deleted: Cell::new(false), |
| internal_format: Cell::new(None), |
| size: Cell::new(None), |
| is_initialized: Cell::new(false), |
| attached_framebuffer: Default::default(), |
| } |
| } |
| |
| pub(crate) fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> { |
| let (sender, receiver) = webgl_channel().unwrap(); |
| context.send_command(WebGLCommand::CreateRenderbuffer(sender)); |
| receiver |
| .recv() |
| .unwrap() |
| .map(|id| WebGLRenderbuffer::new(context, id, CanGc::note())) |
| } |
| |
| pub(crate) fn new( |
| context: &WebGLRenderingContext, |
| id: WebGLRenderbufferId, |
| can_gc: CanGc, |
| ) -> DomRoot<Self> { |
| reflect_dom_object( |
| Box::new(WebGLRenderbuffer::new_inherited(context, id)), |
| &*context.global(), |
| can_gc, |
| ) |
| } |
| } |
| |
| impl WebGLRenderbuffer { |
| pub(crate) fn id(&self) -> WebGLRenderbufferId { |
| self.id |
| } |
| |
| pub(crate) fn size(&self) -> Option<(i32, i32)> { |
| self.size.get() |
| } |
| |
| pub(crate) fn internal_format(&self) -> u32 { |
| self.internal_format.get().unwrap_or(constants::RGBA4) |
| } |
| |
| pub(crate) fn mark_initialized(&self) { |
| self.is_initialized.set(true); |
| } |
| |
| pub(crate) fn is_initialized(&self) -> bool { |
| self.is_initialized.get() |
| } |
| |
| pub(crate) fn bind(&self, target: u32) { |
| self.ever_bound.set(true); |
| self.upcast::<WebGLObject>() |
| .context() |
| .send_command(WebGLCommand::BindRenderbuffer(target, Some(self.id))); |
| } |
| |
| pub(crate) fn delete(&self, operation_fallibility: Operation) { |
| if !self.is_deleted.get() { |
| self.is_deleted.set(true); |
| |
| let context = self.upcast::<WebGLObject>().context(); |
| |
| /* |
| If a renderbuffer object is deleted while its image is attached to one or more |
| attachment points in a currently bound framebuffer object, then it is as if |
| FramebufferRenderbuffer had been called, with a renderbuffer of zero, for each |
| attachment point to which this image was attached in that framebuffer object. |
| In other words,the renderbuffer image is first detached from all attachment points |
| in that frame-buffer object. |
| - GLES 3.0, 4.4.2.3, "Attaching Renderbuffer Images to a Framebuffer" |
| */ |
| if let Some(fb) = context.get_draw_framebuffer_slot().get() { |
| let _ = fb.detach_renderbuffer(self); |
| } |
| if let Some(fb) = context.get_read_framebuffer_slot().get() { |
| let _ = fb.detach_renderbuffer(self); |
| } |
| |
| let cmd = WebGLCommand::DeleteRenderbuffer(self.id); |
| match operation_fallibility { |
| Operation::Fallible => context.send_command_ignored(cmd), |
| Operation::Infallible => context.send_command(cmd), |
| } |
| } |
| } |
| |
| pub(crate) fn is_deleted(&self) -> bool { |
| self.is_deleted.get() |
| } |
| |
| pub(crate) fn ever_bound(&self) -> bool { |
| self.ever_bound.get() |
| } |
| |
| pub(crate) fn storage( |
| &self, |
| api_type: GlType, |
| sample_count: i32, |
| internal_format: u32, |
| width: i32, |
| height: i32, |
| ) -> WebGLResult<()> { |
| let is_gles = api_type == GlType::Gles; |
| let webgl_version = self.upcast().context().webgl_version(); |
| |
| // Validate the internal_format, and save it for completeness |
| // validation. |
| let actual_format = match internal_format { |
| constants::RGBA4 | constants::DEPTH_COMPONENT16 | constants::STENCIL_INDEX8 => { |
| internal_format |
| }, |
| constants::R8 | |
| constants::R8UI | |
| constants::R8I | |
| constants::R16UI | |
| constants::R16I | |
| constants::R32UI | |
| constants::R32I | |
| constants::RG8 | |
| constants::RG8UI | |
| constants::RG8I | |
| constants::RG16UI | |
| constants::RG16I | |
| constants::RG32UI | |
| constants::RG32I | |
| constants::RGB8 | |
| constants::RGBA8 | |
| constants::SRGB8_ALPHA8 | |
| constants::RGB10_A2 | |
| constants::RGBA8UI | |
| constants::RGBA8I | |
| constants::RGB10_A2UI | |
| constants::RGBA16UI | |
| constants::RGBA16I | |
| constants::RGBA32I | |
| constants::RGBA32UI | |
| constants::DEPTH_COMPONENT24 | |
| constants::DEPTH_COMPONENT32F | |
| constants::DEPTH24_STENCIL8 | |
| constants::DEPTH32F_STENCIL8 => match webgl_version { |
| WebGLVersion::WebGL1 => return Err(WebGLError::InvalidEnum), |
| _ => internal_format, |
| }, |
| // https://www.khronos.org/registry/webgl/specs/latest/1.0/#6.8 |
| constants::DEPTH_STENCIL => constants::DEPTH24_STENCIL8, |
| constants::RGB5_A1 => { |
| // 16-bit RGBA formats are not supported on desktop GL. |
| if is_gles { |
| constants::RGB5_A1 |
| } else { |
| constants::RGBA8 |
| } |
| }, |
| constants::RGB565 => { |
| // RGB565 is not supported on desktop GL. |
| if is_gles { |
| constants::RGB565 |
| } else { |
| constants::RGB8 |
| } |
| }, |
| EXTColorBufferHalfFloatConstants::RGBA16F_EXT | |
| EXTColorBufferHalfFloatConstants::RGB16F_EXT => { |
| if !self |
| .upcast() |
| .context() |
| .extension_manager() |
| .is_half_float_buffer_renderable() |
| { |
| return Err(WebGLError::InvalidEnum); |
| } |
| internal_format |
| }, |
| WEBGLColorBufferFloatConstants::RGBA32F_EXT => { |
| if !self |
| .upcast() |
| .context() |
| .extension_manager() |
| .is_float_buffer_renderable() |
| { |
| return Err(WebGLError::InvalidEnum); |
| } |
| internal_format |
| }, |
| _ => return Err(WebGLError::InvalidEnum), |
| }; |
| |
| if webgl_version != WebGLVersion::WebGL1 { |
| let (sender, receiver) = webgl_channel().unwrap(); |
| self.upcast::<WebGLObject>().context().send_command( |
| WebGLCommand::GetInternalFormatIntVec( |
| constants::RENDERBUFFER, |
| internal_format, |
| InternalFormatIntVec::Samples, |
| sender, |
| ), |
| ); |
| let samples = receiver.recv().unwrap(); |
| if sample_count < 0 || sample_count > samples.first().cloned().unwrap_or(0) { |
| return Err(WebGLError::InvalidOperation); |
| } |
| } |
| |
| self.internal_format.set(Some(internal_format)); |
| self.is_initialized.set(false); |
| |
| if let Some(fb) = self.attached_framebuffer.get() { |
| fb.update_status(); |
| } |
| |
| let command = match sample_count { |
| 0 => WebGLCommand::RenderbufferStorage( |
| constants::RENDERBUFFER, |
| actual_format, |
| width, |
| height, |
| ), |
| _ => WebGLCommand::RenderbufferStorageMultisample( |
| constants::RENDERBUFFER, |
| sample_count, |
| actual_format, |
| width, |
| height, |
| ), |
| }; |
| self.upcast::<WebGLObject>().context().send_command(command); |
| |
| self.size.set(Some((width, height))); |
| Ok(()) |
| } |
| |
| pub(crate) fn attach_to_framebuffer(&self, fb: &WebGLFramebuffer) { |
| self.attached_framebuffer.set(Some(fb)); |
| } |
| |
| pub(crate) fn detach_from_framebuffer(&self) { |
| self.attached_framebuffer.set(None); |
| } |
| } |
| |
| impl Drop for WebGLRenderbuffer { |
| fn drop(&mut self) { |
| self.delete(Operation::Fallible); |
| } |
| } |
