Auto merge of #6293 - ecoal95:webgl-objects, r=nox

This commit implements:
* WebGLFramebuffer
* WebGLRenderbuffer
* WebGLTexture

And adds the following methods to `WebGLRenderingContext`:
* create{Texture,Framebuffer,Renderbuffer}
* bind{Texture,Framebuffer,Renderbuffer}
* destroy{Buffer,Texture,Framebuffer,Renderbuffer}

Fixes:
* WebGLUniform location shouldn't inherit from WebGLObject.

Known Issues:
* WebGL objects have to be destroyed on drop, we may want to keep a reference to the context, or maybe a clone of the renderer to achieve this

Also refactors a huge part of the current implementation, to allow
failing on creation of different WebGL objects.

Blocked on https://github.com/servo/gleam/pull/22

A reftest for most of the added functionality is not doable right now,
we need a few more functions in order to upload a texture, for example.

<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/6293)
<!-- Reviewable:end -->

components/script/dom/mod.rs

@@ -332,6 +332,9 @@ pub mod webglprogram;
 pub mod webglrenderingcontext;
 pub mod webglshader;
 pub mod webgluniformlocation;
+pub mod webgltexture;
+pub mod webglframebuffer;
+pub mod webglrenderbuffer;
 pub mod websocket;
 pub mod window;
 pub mod worker;

components/script/dom/webglframebuffer.rs

@@ -0,0 +1,39 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
+use dom::bindings::codegen::Bindings::WebGLFramebufferBinding;
+use dom::bindings::global::GlobalRef;
+use dom::bindings::js::{Temporary, JSRef};
+use dom::bindings::utils::reflect_dom_object;
+use dom::webglobject::WebGLObject;
+
+#[dom_struct]
+pub struct WebGLFramebuffer {
+    webgl_object: WebGLObject,
+    id: u32,
+}
+
+impl WebGLFramebuffer {
+    fn new_inherited(id: u32) -> WebGLFramebuffer {
+        WebGLFramebuffer {
+            webgl_object: WebGLObject::new_inherited(),
+            id: id,
+        }
+    }
+
+    pub fn new(global: GlobalRef, id: u32) -> Temporary<WebGLFramebuffer> {
+        reflect_dom_object(box WebGLFramebuffer::new_inherited(id), global, WebGLFramebufferBinding::Wrap)
+    }
+}
+
+pub trait WebGLFramebufferHelpers {
+    fn get_id(&self) -> u32;
+}
+
+impl<'a> WebGLFramebufferHelpers for JSRef<'a, WebGLFramebuffer> {
+    fn get_id(&self) -> u32 {
+        self.id
+    }
+}

components/script/dom/webglrenderbuffer.rs

@@ -0,0 +1,39 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
+use dom::bindings::codegen::Bindings::WebGLRenderbufferBinding;
+use dom::bindings::global::GlobalRef;
+use dom::bindings::js::{Temporary, JSRef};
+use dom::bindings::utils::reflect_dom_object;
+use dom::webglobject::WebGLObject;
+
+#[dom_struct]
+pub struct WebGLRenderbuffer {
+    webgl_object: WebGLObject,
+    id: u32,
+}
+
+impl WebGLRenderbuffer {
+    fn new_inherited(id: u32) -> WebGLRenderbuffer {
+        WebGLRenderbuffer {
+            webgl_object: WebGLObject::new_inherited(),
+            id: id,
+        }
+    }
+
+    pub fn new(global: GlobalRef, id: u32) -> Temporary<WebGLRenderbuffer> {
+        reflect_dom_object(box WebGLRenderbuffer::new_inherited(id), global, WebGLRenderbufferBinding::Wrap)
+    }
+}
+
+pub trait WebGLRenderbufferHelpers {
+    fn get_id(&self) -> u32;
+}
+
+impl<'a> WebGLRenderbufferHelpers for JSRef<'a, WebGLRenderbuffer> {
+    fn get_id(&self) -> u32 {
+        self.id
+    }
+}

components/script/dom/webglrenderingcontext.rs

@@ -13,6 +13,9 @@ use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::bindings::conversions::ToJSValConvertible;
 use dom::htmlcanvaselement::{HTMLCanvasElement};
 use dom::webglbuffer::{WebGLBuffer, WebGLBufferHelpers};
+use dom::webglframebuffer::{WebGLFramebuffer, WebGLFramebufferHelpers};
+use dom::webglrenderbuffer::{WebGLRenderbuffer, WebGLRenderbufferHelpers};
+use dom::webgltexture::{WebGLTexture, WebGLTextureHelpers};
 use dom::webglshader::{WebGLShader, WebGLShaderHelpers};
 use dom::webglprogram::{WebGLProgram, WebGLProgramHelpers};
 use dom::webgluniformlocation::{WebGLUniformLocation, WebGLUniformLocationHelpers};
@@ -128,6 +131,13 @@ impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> {
         })
     }
 
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.14
+    fn GetExtension(self, _cx: *mut JSContext, _name: DOMString) -> *mut JSObject {
+        // TODO(ecoal95) we actually do not support extensions.
+        // `getSupportedExtensions` cannot be implemented as of right now (see #544)
+        0 as *mut JSObject
+    }
+
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn AttachShader(self, program: Option<JSRef<WebGLProgram>>, shader: Option<JSRef<WebGLShader>>) {
         let program_id = match program {
@@ -142,12 +152,31 @@ impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> {
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
-    fn BindBuffer(self, buffer_type: u32, buffer: Option<JSRef<WebGLBuffer>>) {
-        let buffer_id = match buffer {
-            Some(buffer) => buffer.get_id(),
-            None => return,
-        };
-        self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::BindBuffer(buffer_type, buffer_id))).unwrap()
+    fn BindBuffer(self, target: u32, buffer: Option<JSRef<WebGLBuffer>>) {
+        let id = buffer.map(|buf| buf.get_id()).unwrap_or(0);
+        self.renderer.send(
+            CanvasMsg::WebGL(CanvasWebGLMsg::BindBuffer(target, id))).unwrap()
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
+    fn BindFramebuffer(self, target: u32, framebuffer: Option<JSRef<WebGLFramebuffer>>) {
+        let id = framebuffer.map(|fb| fb.get_id()).unwrap_or(0);
+        self.renderer.send(
+            CanvasMsg::WebGL(CanvasWebGLMsg::BindFramebuffer(target, id))).unwrap()
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
+    fn BindRenderbuffer(self, target: u32, renderbuffer: Option<JSRef<WebGLRenderbuffer>>) {
+        let id = renderbuffer.map(|rb| rb.get_id()).unwrap_or(0);
+        self.renderer.send(
+            CanvasMsg::WebGL(CanvasWebGLMsg::BindRenderbuffer(target, id))).unwrap()
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
+    fn BindTexture(self, target: u32, texture: Option<JSRef<WebGLTexture>>) {
+        let id = texture.map(|tex| tex.get_id()).unwrap_or(0);
+        self.renderer.send(
+            CanvasMsg::WebGL(CanvasWebGLMsg::BindTexture(target, id))).unwrap()
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
@@ -191,25 +220,98 @@ impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> {
         self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::CompileShader(shader_id))).unwrap()
     }
 
+    // TODO(ecoal95): Probably in the future we should keep track of the
+    // generated objects, either here or in the webgl task
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
     fn CreateBuffer(self) -> Option<Temporary<WebGLBuffer>> {
-        let (sender, receiver) = channel::<u32>();
+        let (sender, receiver) = channel();
         self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::CreateBuffer(sender))).unwrap();
-        Some(WebGLBuffer::new(self.global.root().r(), receiver.recv().unwrap()))
+        receiver.recv().unwrap()
+            .map(|buffer_id| WebGLBuffer::new(self.global.root().r(), *buffer_id))
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
+    fn CreateFramebuffer(self) -> Option<Temporary<WebGLFramebuffer>> {
+        let (sender, receiver) = channel();
+        self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::CreateFramebuffer(sender))).unwrap();
+        receiver.recv().unwrap()
+            .map(|fb_id| WebGLFramebuffer::new(self.global.root().r(), *fb_id))
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
+    fn CreateRenderbuffer(self) -> Option<Temporary<WebGLRenderbuffer>> {
+        let (sender, receiver) = channel();
+        self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::CreateRenderbuffer(sender))).unwrap();
+        receiver.recv().unwrap()
+            .map(|program_id| WebGLRenderbuffer::new(self.global.root().r(), *program_id))
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
+    fn CreateTexture(self) -> Option<Temporary<WebGLTexture>> {
+        let (sender, receiver) = channel();
+        self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::CreateTexture(sender))).unwrap();
+        receiver.recv().unwrap()
+            .map(|texture_id| WebGLTexture::new(self.global.root().r(), *texture_id))
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn CreateProgram(self) -> Option<Temporary<WebGLProgram>> {
-        let (sender, receiver) = channel::<u32>();
+        let (sender, receiver) = channel();
         self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::CreateProgram(sender))).unwrap();
-        Some(WebGLProgram::new(self.global.root().r(), receiver.recv().unwrap()))
+        receiver.recv().unwrap()
+            .map(|program_id| WebGLProgram::new(self.global.root().r(), *program_id))
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
+    // TODO(ecoal95): Check if constants are cross-platform or if we must make a translation
+    // between WebGL constants and native ones.
     fn CreateShader(self, shader_type: u32) -> Option<Temporary<WebGLShader>> {
-        let (sender, receiver) = channel::<u32>();
+        let (sender, receiver) = channel();
         self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::CreateShader(shader_type, sender))).unwrap();
-        Some(WebGLShader::new(self.global.root().r(), receiver.recv().unwrap()))
+        receiver.recv().unwrap()
+            .map(|shader_id| WebGLShader::new(self.global.root().r(), *shader_id))
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
+    fn DeleteBuffer(self, buffer: Option<JSRef<WebGLBuffer>>) {
+        if let Some(buffer) = buffer {
+            self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::DeleteBuffer(buffer.get_id()))).unwrap();
+        }
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
+    fn DeleteFramebuffer(self, framebuffer: Option<JSRef<WebGLFramebuffer>>) {
+        if let Some(framebuffer) = framebuffer {
+            self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::DeleteFramebuffer(framebuffer.get_id()))).unwrap();
+        }
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
+    fn DeleteRenderbuffer(self, renderbuffer: Option<JSRef<WebGLRenderbuffer>>) {
+        if let Some(renderbuffer) = renderbuffer {
+            self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::DeleteRenderbuffer(renderbuffer.get_id()))).unwrap();
+        }
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
+    fn DeleteTexture(self, texture: Option<JSRef<WebGLTexture>>) {
+        if let Some(texture) = texture {
+            self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::DeleteTexture(texture.get_id()))).unwrap();
+        }
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
+    fn DeleteProgram(self, program: Option<JSRef<WebGLProgram>>) {
+        if let Some(program) = program {
+            self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::DeleteProgram(program.get_id()))).unwrap();
+        }
+    }
+
+    // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
+    fn DeleteShader(self, shader: Option<JSRef<WebGLShader>>) {
+        if let Some(shader) = shader {
+            self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::DeleteShader(shader.get_id()))).unwrap();
+        }
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.11
@@ -228,69 +330,62 @@ impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> {
             Some(program) => program.get_id(),
             None => return -1,
         };
-        let (sender, receiver) = channel::<i32>();
+        let (sender, receiver) = channel();
         self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::GetAttribLocation(program_id, name, sender))).unwrap();
         receiver.recv().unwrap()
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn GetShaderInfoLog(self, shader: Option<JSRef<WebGLShader>>) -> Option<DOMString> {
-        let shader_id = match shader {
-            Some(shader) => shader.get_id(),
-            None => return None,
-        };
-        let (sender, receiver) = channel::<String>();
-        self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::GetShaderInfoLog(shader_id, sender))).unwrap();
-        let info = receiver.recv().unwrap();
-        Some(info)
+        if let Some(shader) = shader {
+            let (sender, receiver) = channel();
+            self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::GetShaderInfoLog(shader.get_id(), sender))).unwrap();
+            Some(receiver.recv().unwrap())
+        } else {
+            None
+        }
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn GetShaderParameter(self, _: *mut JSContext, shader: Option<JSRef<WebGLShader>>, param_id: u32) -> JSVal {
-        let shader_id = match shader {
-            Some(shader) => shader.get_id(),
-            None => return NullValue(),
-        };
-        let (sender, receiver) = channel::<i32>();
-        let msg = CanvasMsg::WebGL(CanvasWebGLMsg::GetShaderParameter(shader_id, param_id, sender));
-        self.renderer.send(msg).unwrap();
-        Int32Value(receiver.recv().unwrap())
+        if let Some(shader) = shader {
+            let (sender, receiver) = channel();
+            self.renderer.send(
+                CanvasMsg::WebGL(CanvasWebGLMsg::GetShaderParameter(shader.get_id(), param_id, sender))).unwrap();
+            Int32Value(receiver.recv().unwrap())
+        } else {
+            NullValue()
+        }
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
     fn GetUniformLocation(self,
                           program: Option<JSRef<WebGLProgram>>,
                           name: DOMString) -> Option<Temporary<WebGLUniformLocation>> {
-        let program_id = match program {
-            Some(program) => program.get_id(),
-            None => return None,
-        };
-        let (sender, receiver) = channel::<u32>();
-        self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::GetUniformLocation(program_id, name, sender))).unwrap();
-        Some(WebGLUniformLocation::new(self.global.root().r(), receiver.recv().unwrap()))
+        if let Some(program) = program {
+            let (sender, receiver) = channel();
+            self.renderer.send(
+                CanvasMsg::WebGL(CanvasWebGLMsg::GetUniformLocation(program.get_id(), name, sender))).unwrap();
+            receiver.recv().unwrap()
+                .map(|location| WebGLUniformLocation::new(self.global.root().r(), location))
+        } else {
+            None
+        }
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn LinkProgram(self, program: Option<JSRef<WebGLProgram>>) {
-        let program_id = match program {
-            Some(program) => program.get_id(),
-            None => return,
-        };
-        self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::LinkProgram(program_id))).unwrap()
+        if let Some(program) = program {
+            self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::LinkProgram(program.get_id()))).unwrap()
+        }
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn ShaderSource(self, shader: Option<JSRef<WebGLShader>>, source: DOMString) {
-        let shader_id = match shader {
-            Some(shader) => shader.get_id(),
-            None => return,
-        };
-        let source_lines: Vec<String> = source.trim()
-                                              .split(|c: char| c == '\n')
-                                              .map(|line: &str| String::from_str(line) + "\n")
-                                              .collect();
-        let msg = CanvasMsg::WebGL(CanvasWebGLMsg::ShaderSource(shader_id, source_lines));
-        self.renderer.send(msg).unwrap()
+        if let Some(shader) = shader {
+            self.renderer.send(
+                CanvasMsg::WebGL(CanvasWebGLMsg::ShaderSource(shader.get_id(), source))).unwrap();
+        }
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
@@ -303,10 +398,12 @@ impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> {
             Some(uniform) => uniform.get_id(),
             None => return,
         };
+
         let data = match data {
             Some(data) => data,
             None => return,
         };
+
         let data_vec: Vec<f32>;
         unsafe {
             let data_f32 = JS_GetFloat32ArrayData(data, cx);

components/script/dom/webgltexture.rs

@@ -0,0 +1,39 @@
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
+use dom::bindings::codegen::Bindings::WebGLTextureBinding;
+use dom::bindings::global::GlobalRef;
+use dom::bindings::js::{Temporary, JSRef};
+use dom::bindings::utils::reflect_dom_object;
+use dom::webglobject::WebGLObject;
+
+#[dom_struct]
+pub struct WebGLTexture {
+    webgl_object: WebGLObject,
+    id: u32,
+}
+
+impl WebGLTexture {
+    fn new_inherited(id: u32) -> WebGLTexture {
+        WebGLTexture {
+            webgl_object: WebGLObject::new_inherited(),
+            id: id,
+        }
+    }
+
+    pub fn new(global: GlobalRef, id: u32) -> Temporary<WebGLTexture> {
+        reflect_dom_object(box WebGLTexture::new_inherited(id), global, WebGLTextureBinding::Wrap)
+    }
+}
+
+pub trait WebGLTextureHelpers {
+    fn get_id(&self) -> u32;
+}
+
+impl<'a> WebGLTextureHelpers for JSRef<'a, WebGLTexture> {
+    fn get_id(&self) -> u32 {
+        self.id
+    }
+}

components/script/dom/webgluniformlocation.rs

@@ -6,34 +6,33 @@
 use dom::bindings::codegen::Bindings::WebGLUniformLocationBinding;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Temporary, JSRef};
-use dom::bindings::utils::reflect_dom_object;
-use dom::webglobject::WebGLObject;
+use dom::bindings::utils::{Reflector,reflect_dom_object};
 
 #[dom_struct]
 pub struct WebGLUniformLocation {
-    webgl_object: WebGLObject,
-    id: u32,
+    reflector_: Reflector,
+    id: i32,
 }
 
 impl WebGLUniformLocation {
-    fn new_inherited(id: u32) -> WebGLUniformLocation {
+    fn new_inherited(id: i32) -> WebGLUniformLocation {
         WebGLUniformLocation {
-            webgl_object: WebGLObject::new_inherited(),
+            reflector_: Reflector::new(),
             id: id,
         }
     }
 
-    pub fn new(global: GlobalRef, id: u32) -> Temporary<WebGLUniformLocation> {
+    pub fn new(global: GlobalRef, id: i32) -> Temporary<WebGLUniformLocation> {
         reflect_dom_object(box WebGLUniformLocation::new_inherited(id), global, WebGLUniformLocationBinding::Wrap)
     }
 }
 
 pub trait WebGLUniformLocationHelpers {
-    fn get_id(&self) -> u32;
+    fn get_id(&self) -> i32;
 }
 
 impl<'a> WebGLUniformLocationHelpers for JSRef<'a, WebGLUniformLocation> {
-    fn get_id(&self) -> u32 {
+    fn get_id(&self) -> i32 {
         self.id
     }
 }

components/script/dom/webidls/WebGLFramebuffer.webidl

@@ -0,0 +1,7 @@
+//
+// WebGL IDL definitions scraped from the Khronos specification:
+// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.7
+//
+
+interface WebGLFramebuffer : WebGLObject {
+};

components/script/dom/webidls/WebGLRenderbuffer.webidl

@@ -0,0 +1,7 @@
+//
+// WebGL IDL definitions scraped from the Khronos specification:
+// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.5
+//
+
+interface WebGLRenderbuffer : WebGLObject {
+};

components/script/dom/webidls/WebGLRenderingContext.webidl

@@ -485,15 +485,15 @@ interface WebGLRenderingContextBase
     //[WebGLHandlesContextLoss] boolean isContextLost();
 
     //sequence<DOMString>? getSupportedExtensions();
-    //object? getExtension(DOMString name);
+    object? getExtension(DOMString name);
 
     //void activeTexture(GLenum texture);
     void attachShader(WebGLProgram? program, WebGLShader? shader);
     //void bindAttribLocation(WebGLProgram? program, GLuint index, DOMString name);
     void bindBuffer(GLenum target, WebGLBuffer? buffer);
-    //void bindFramebuffer(GLenum target, WebGLFramebuffer? framebuffer);
-    //void bindRenderbuffer(GLenum target, WebGLRenderbuffer? renderbuffer);
-    //void bindTexture(GLenum target, WebGLTexture? texture);
+    void bindFramebuffer(GLenum target, WebGLFramebuffer? framebuffer);
+    void bindRenderbuffer(GLenum target, WebGLRenderbuffer? renderbuffer);
+    void bindTexture(GLenum target, WebGLTexture? texture);
     //void blendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
     //void blendEquation(GLenum mode);
     //void blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
@@ -533,20 +533,20 @@ interface WebGLRenderingContextBase
     //                       GLint x, GLint y, GLsizei width, GLsizei height);
 
     WebGLBuffer? createBuffer();
-    //WebGLFramebuffer? createFramebuffer();
+    WebGLFramebuffer? createFramebuffer();
     WebGLProgram? createProgram();
-    //WebGLRenderbuffer? createRenderbuffer();
+    WebGLRenderbuffer? createRenderbuffer();
     WebGLShader? createShader(GLenum type);
-    //WebGLTexture? createTexture();
+    WebGLTexture? createTexture();
 
     //void cullFace(GLenum mode);
 
-    //void deleteBuffer(WebGLBuffer? buffer);
-    //void deleteFramebuffer(WebGLFramebuffer? framebuffer);
-    //void deleteProgram(WebGLProgram? program);
-    //void deleteRenderbuffer(WebGLRenderbuffer? renderbuffer);
-    //void deleteShader(WebGLShader? shader);
-    //void deleteTexture(WebGLTexture? texture);
+    void deleteBuffer(WebGLBuffer? buffer);
+    void deleteFramebuffer(WebGLFramebuffer? framebuffer);
+    void deleteProgram(WebGLProgram? program);
+    void deleteRenderbuffer(WebGLRenderbuffer? renderbuffer);
+    void deleteShader(WebGLShader? shader);
+    void deleteTexture(WebGLTexture? texture);
 
     //void depthFunc(GLenum func);
     //void depthMask(GLboolean flag);

components/script/dom/webidls/WebGLTexture.webidl

@@ -0,0 +1,7 @@
+//
+// WebGL IDL definitions scraped from the Khronos specification:
+// https://www.khronos.org/registry/webgl/specs/latest/#5.9
+//
+
+interface WebGLTexture : WebGLObject {
+};