diff options
23 files changed, 1325 insertions, 164 deletions
diff --git a/components/canvas/Cargo.toml b/components/canvas/Cargo.toml index a682f1069bb..df07dbd1de0 100644 --- a/components/canvas/Cargo.toml +++ b/components/canvas/Cargo.toml @@ -16,6 +16,17 @@ git = "https://github.com/servo/rust-cssparser" [dependencies.geom] git = "https://github.com/servo/rust-geom" +[dependencies.gleam] +git = "https://github.com/servo/gleam" + +[dependencies.glutin] +git = "https://github.com/servo/glutin" +branch = "servo" +features = ["headless"] + +[dependencies.msg] +path = "../msg" + [dependencies.util] path = "../util" diff --git a/components/canvas/canvas_msg.rs b/components/canvas/canvas_msg.rs new file mode 100644 index 00000000000..3d21da3ae0a --- /dev/null +++ b/components/canvas/canvas_msg.rs @@ -0,0 +1,61 @@ +/* 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/. */ + +use canvas_paint_task::{FillOrStrokeStyle, LineCapStyle, LineJoinStyle}; +use geom::matrix2d::Matrix2D; +use geom::point::Point2D; +use geom::rect::Rect; +use geom::size::Size2D; +use std::sync::mpsc::{Sender}; + +#[derive(Clone)] +pub enum CanvasMsg { + Canvas2d(Canvas2dMsg), + Common(CanvasCommonMsg), + WebGL(CanvasWebGLMsg), +} + +#[derive(Clone)] +pub enum Canvas2dMsg { + Arc(Point2D<f32>, f32, f32, f32, bool), + ArcTo(Point2D<f32>, Point2D<f32>, f32), + DrawImage(Vec<u8>, Size2D<f64>, Rect<f64>, Rect<f64>, bool), + DrawImageSelf(Size2D<f64>, Rect<f64>, Rect<f64>, bool), + BeginPath, + BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>), + ClosePath, + ClearRect(Rect<f32>), + Fill, + FillRect(Rect<f32>), + GetImageData(Rect<f64>, Size2D<f64>, Sender<Vec<u8>>), + LineTo(Point2D<f32>), + MoveTo(Point2D<f32>), + PutImageData(Vec<u8>, Rect<f64>, Option<Rect<f64>>), + QuadraticCurveTo(Point2D<f32>, Point2D<f32>), + RestoreContext, + SaveContext, + StrokeRect(Rect<f32>), + Stroke, + SetFillStyle(FillOrStrokeStyle), + SetStrokeStyle(FillOrStrokeStyle), + SetLineWidth(f32), + SetLineCap(LineCapStyle), + SetLineJoin(LineJoinStyle), + SetMiterLimit(f32), + SetGlobalAlpha(f32), + SetTransform(Matrix2D<f32>), +} + +#[derive(Clone)] +pub enum CanvasWebGLMsg { + Clear(u32), + ClearColor(f32, f32, f32, f32), +} + +#[derive(Clone)] +pub enum CanvasCommonMsg { + Close, + Recreate(Size2D<i32>), + SendPixelContents(Sender<Vec<u8>>), +} diff --git a/components/canvas/canvas_paint_task.rs b/components/canvas/canvas_paint_task.rs index f45c4d79c14..bbce09cea23 100644 --- a/components/canvas/canvas_paint_task.rs +++ b/components/canvas/canvas_paint_task.rs @@ -6,6 +6,7 @@ use azure::azure::AzFloat; use azure::azure_hl::{DrawTarget, SurfaceFormat, BackendType, StrokeOptions, DrawOptions, Pattern}; use azure::azure_hl::{ColorPattern, PathBuilder, JoinStyle, CapStyle, DrawSurfaceOptions, Filter}; use azure::azure_hl::{GradientStop, LinearGradientPattern, RadialGradientPattern, ExtendMode}; +use canvas_msg::{CanvasMsg, Canvas2dMsg, CanvasCommonMsg}; use geom::matrix2d::Matrix2D; use geom::point::Point2D; use geom::rect::Rect; @@ -20,40 +21,6 @@ use std::mem; use std::num::{Float, ToPrimitive}; use std::sync::mpsc::{channel, Sender}; -#[derive(Clone)] -pub enum CanvasMsg { - SaveContext, - RestoreContext, - FillRect(Rect<f32>), - ClearRect(Rect<f32>), - StrokeRect(Rect<f32>), - BeginPath, - ClosePath, - Fill, - Stroke, - DrawImage(Vec<u8>, Size2D<f64>, Rect<f64>, Rect<f64>, bool), - DrawImageSelf(Size2D<f64>, Rect<f64>, Rect<f64>, bool), - MoveTo(Point2D<f32>), - LineTo(Point2D<f32>), - QuadraticCurveTo(Point2D<f32>, Point2D<f32>), - BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>), - Arc(Point2D<f32>, f32, f32, f32, bool), - ArcTo(Point2D<f32>, Point2D<f32>, f32), - SetFillStyle(FillOrStrokeStyle), - SetStrokeStyle(FillOrStrokeStyle), - SetLineWidth(f32), - SetLineCap(LineCapStyle), - SetLineJoin(LineJoinStyle), - SetMiterLimit(f32), - SetTransform(Matrix2D<f32>), - SetGlobalAlpha(f32), - Recreate(Size2D<i32>), - SendPixelContents(Sender<Vec<u8>>), - GetImageData(Rect<f64>, Size2D<f64>, Sender<Vec<u8>>), - PutImageData(Vec<u8>, Rect<f64>, Option<Rect<f64>>), - Close, -} - impl<'a> CanvasPaintTask<'a> { /// It reads image data from the canvas /// canvas_size: The size of the canvas we're reading from @@ -236,49 +203,59 @@ impl<'a> CanvasPaintTask<'a> { loop { match port.recv().unwrap() { - CanvasMsg::SaveContext => painter.save_context_state(), - CanvasMsg::RestoreContext => painter.restore_context_state(), - CanvasMsg::FillRect(ref rect) => painter.fill_rect(rect), - CanvasMsg::StrokeRect(ref rect) => painter.stroke_rect(rect), - CanvasMsg::ClearRect(ref rect) => painter.clear_rect(rect), - CanvasMsg::BeginPath => painter.begin_path(), - CanvasMsg::ClosePath => painter.close_path(), - CanvasMsg::Fill => painter.fill(), - CanvasMsg::Stroke => painter.stroke(), - CanvasMsg::DrawImage(imagedata, image_size, dest_rect, source_rect, smoothing_enabled) => { - painter.draw_image(imagedata, image_size, dest_rect, source_rect, smoothing_enabled) - } - CanvasMsg::DrawImageSelf(image_size, dest_rect, source_rect, smoothing_enabled) => { - painter.draw_image_self(image_size, dest_rect, source_rect, smoothing_enabled) - } - CanvasMsg::MoveTo(ref point) => painter.move_to(point), - CanvasMsg::LineTo(ref point) => painter.line_to(point), - CanvasMsg::QuadraticCurveTo(ref cp, ref pt) => { - painter.quadratic_curve_to(cp, pt) - } - CanvasMsg::BezierCurveTo(ref cp1, ref cp2, ref pt) => { - painter.bezier_curve_to(cp1, cp2, pt) - } - CanvasMsg::Arc(ref center, radius, start, end, ccw) => { - painter.arc(center, radius, start, end, ccw) - } - CanvasMsg::ArcTo(ref cp1, ref cp2, radius) => { - painter.arc_to(cp1, cp2, radius) - } - CanvasMsg::SetFillStyle(style) => painter.set_fill_style(style), - CanvasMsg::SetStrokeStyle(style) => painter.set_stroke_style(style), - CanvasMsg::SetLineWidth(width) => painter.set_line_width(width), - CanvasMsg::SetLineCap(cap) => painter.set_line_cap(cap), - CanvasMsg::SetLineJoin(join) => painter.set_line_join(join), - CanvasMsg::SetMiterLimit(limit) => painter.set_miter_limit(limit), - CanvasMsg::SetTransform(ref matrix) => painter.set_transform(matrix), - CanvasMsg::SetGlobalAlpha(alpha) => painter.set_global_alpha(alpha), - CanvasMsg::Recreate(size) => painter.recreate(size), - CanvasMsg::SendPixelContents(chan) => painter.send_pixel_contents(chan), - CanvasMsg::GetImageData(dest_rect, canvas_size, chan) => painter.get_image_data(dest_rect, canvas_size, chan), - CanvasMsg::PutImageData(imagedata, image_data_rect, dirty_rect) - => painter.put_image_data(imagedata, image_data_rect, dirty_rect), - CanvasMsg::Close => break, + CanvasMsg::Canvas2d(message) => { + match message { + Canvas2dMsg::FillRect(ref rect) => painter.fill_rect(rect), + Canvas2dMsg::StrokeRect(ref rect) => painter.stroke_rect(rect), + Canvas2dMsg::ClearRect(ref rect) => painter.clear_rect(rect), + Canvas2dMsg::BeginPath => painter.begin_path(), + Canvas2dMsg::ClosePath => painter.close_path(), + Canvas2dMsg::Fill => painter.fill(), + Canvas2dMsg::Stroke => painter.stroke(), + Canvas2dMsg::DrawImage(imagedata, image_size, dest_rect, source_rect, smoothing_enabled) => { + painter.draw_image(imagedata, image_size, dest_rect, source_rect, smoothing_enabled) + } + Canvas2dMsg::DrawImageSelf(image_size, dest_rect, source_rect, smoothing_enabled) => { + painter.draw_image_self(image_size, dest_rect, source_rect, smoothing_enabled) + } + Canvas2dMsg::MoveTo(ref point) => painter.move_to(point), + Canvas2dMsg::LineTo(ref point) => painter.line_to(point), + Canvas2dMsg::QuadraticCurveTo(ref cp, ref pt) => { + painter.quadratic_curve_to(cp, pt) + } + Canvas2dMsg::BezierCurveTo(ref cp1, ref cp2, ref pt) => { + painter.bezier_curve_to(cp1, cp2, pt) + } + Canvas2dMsg::Arc(ref center, radius, start, end, ccw) => { + painter.arc(center, radius, start, end, ccw) + } + Canvas2dMsg::ArcTo(ref cp1, ref cp2, radius) => { + painter.arc_to(cp1, cp2, radius) + } + Canvas2dMsg::RestoreContext => painter.restore_context_state(), + Canvas2dMsg::SaveContext => painter.save_context_state(), + Canvas2dMsg::SetFillStyle(style) => painter.set_fill_style(style), + Canvas2dMsg::SetStrokeStyle(style) => painter.set_stroke_style(style), + Canvas2dMsg::SetLineWidth(width) => painter.set_line_width(width), + Canvas2dMsg::SetLineCap(cap) => painter.set_line_cap(cap), + Canvas2dMsg::SetLineJoin(join) => painter.set_line_join(join), + Canvas2dMsg::SetMiterLimit(limit) => painter.set_miter_limit(limit), + Canvas2dMsg::SetTransform(ref matrix) => painter.set_transform(matrix), + Canvas2dMsg::SetGlobalAlpha(alpha) => painter.set_global_alpha(alpha), + Canvas2dMsg::GetImageData(dest_rect, canvas_size, chan) => painter.get_image_data(dest_rect, canvas_size, chan), + Canvas2dMsg::PutImageData(imagedata, image_data_rect, dirty_rect) + => painter.put_image_data(imagedata, image_data_rect, dirty_rect), + } + }, + CanvasMsg::Common(message) => { + match message { + CanvasCommonMsg::Close => break, + CanvasCommonMsg::Recreate(size) => painter.recreate(size), + CanvasCommonMsg::SendPixelContents(chan) => + painter.send_pixel_contents(chan), + } + }, + CanvasMsg::WebGL(_) => panic!("Wrong message sent to Canvas2D task"), } } }); diff --git a/components/canvas/lib.rs b/components/canvas/lib.rs index 2b5c51feec1..5feab435394 100644 --- a/components/canvas/lib.rs +++ b/components/canvas/lib.rs @@ -11,6 +11,10 @@ extern crate cssparser; extern crate geom; extern crate gfx; extern crate util; - +extern crate gleam; +extern crate msg; +extern crate glutin; pub mod canvas_paint_task; +pub mod webgl_paint_task; +pub mod canvas_msg; diff --git a/components/canvas/webgl_paint_task.rs b/components/canvas/webgl_paint_task.rs new file mode 100644 index 00000000000..1afcf20089c --- /dev/null +++ b/components/canvas/webgl_paint_task.rs @@ -0,0 +1,112 @@ +/* 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/. */ + +use canvas_msg::{CanvasWebGLMsg, CanvasCommonMsg, CanvasMsg}; +use geom::size::Size2D; + +use gleam::gl; +use gleam::gl::types::{GLint, GLsizei}; + +use util::task::spawn_named; + +use std::borrow::ToOwned; +use std::sync::mpsc::{channel, Sender}; +use util::vec::byte_swap; + +use glutin::{HeadlessRendererBuilder}; + +pub struct WebGLPaintTask { + size: Size2D<i32>, +} + +impl WebGLPaintTask { + fn new(size: Size2D<i32>) -> WebGLPaintTask { + WebGLPaintTask::create(size); + WebGLPaintTask { + size: size, + } + } + + pub fn start(size: Size2D<i32>) -> Sender<CanvasMsg> { + let (chan, port) = channel::<CanvasMsg>(); + spawn_named("WebGLTask".to_owned(), move || { + let mut painter = WebGLPaintTask::new(size); + painter.init(); + loop { + match port.recv().unwrap() { + CanvasMsg::WebGL(message) => { + match message { + CanvasWebGLMsg::Clear(mask) => painter.clear(mask), + CanvasWebGLMsg::ClearColor(r, g, b, a) => painter.clear_color(r, g, b, a), + } + }, + CanvasMsg::Common(message) => { + match message { + CanvasCommonMsg::Close => break, + CanvasCommonMsg::SendPixelContents(chan) => painter.send_pixel_contents(chan), + CanvasCommonMsg::Recreate(size) => painter.recreate(size), + } + }, + CanvasMsg::Canvas2d(_) => panic!("Wrong message sent to WebGLTask"), + } + } + }); + chan + } + + fn create(size: Size2D<i32>) { + // It creates OpenGL context + let context = HeadlessRendererBuilder::new(size.width as u32, size.height as u32).build().unwrap(); + unsafe { + context.make_current(); + } + } + + fn init(&self) { + let framebuffer_ids = gl::gen_framebuffers(1); + gl::bind_framebuffer(gl::FRAMEBUFFER, framebuffer_ids[0]); + + let texture_ids = gl::gen_textures(1); + gl::bind_texture(gl::TEXTURE_2D, texture_ids[0]); + + gl::tex_image_2d(gl::TEXTURE_2D, 0, gl::RGB as GLint, self.size.width as GLsizei, + self.size.height as GLsizei, 0, gl::RGB, gl::UNSIGNED_BYTE, None); + gl::tex_parameter_i(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST as GLint); + gl::tex_parameter_i(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST as GLint); + + gl::framebuffer_texture_2d(gl::FRAMEBUFFER, gl::COLOR_ATTACHMENT0, gl::TEXTURE_2D, + texture_ids[0], 0); + gl::bind_texture(gl::TEXTURE_2D, 0); + + gl::viewport(0 as GLint, 0 as GLint, + self.size.width as GLsizei, self.size.height as GLsizei); + } + + fn clear(&self, mask: u32) { + gl::clear(mask); + } + + fn clear_color(&self, r: f32, g: f32, b: f32, a: f32) { + gl::clear_color(r, g, b, a); + } + + fn send_pixel_contents(&mut self, chan: Sender<Vec<u8>>) { + // FIXME(#5652, dmarcos) Instead of a readback strategy we have + // to layerize the canvas + let mut pixels = gl::read_pixels(0, 0, + self.size.width as gl::GLsizei, + self.size.height as gl::GLsizei, + gl::RGBA, gl::UNSIGNED_BYTE); + + // rgba -> bgra + byte_swap(pixels.as_mut_slice()); + chan.send(pixels).unwrap(); + } + + fn recreate(&mut self, size: Size2D<i32>) { + self.size = size; + self.init(); + } + +} diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs index e92d0411216..3e1af9c16b8 100644 --- a/components/layout/display_list_builder.rs +++ b/components/layout/display_list_builder.rs @@ -12,7 +12,7 @@ use azure::azure_hl::Color; use block::BlockFlow; -use canvas::canvas_paint_task::CanvasMsg::SendPixelContents; +use canvas::canvas_msg::{CanvasMsg, CanvasCommonMsg}; use context::LayoutContext; use flow::{self, BaseFlow, Flow, IS_ABSOLUTELY_POSITIONED, NEEDS_LAYER}; use fragment::{CoordinateSystem, Fragment, IframeFragmentInfo, ImageFragmentInfo}; @@ -1004,7 +1004,7 @@ impl FragmentDisplayListBuilding for Fragment { let (sender, receiver) = channel::<Vec<u8>>(); let canvas_data = match canvas_fragment_info.renderer { Some(ref renderer) => { - renderer.lock().unwrap().send(SendPixelContents(sender)).unwrap(); + renderer.lock().unwrap().send(CanvasMsg::Common(CanvasCommonMsg::SendPixelContents(sender))).unwrap(); receiver.recv().unwrap() }, None => repeat(0xFFu8).take(width * height * 4).collect(), diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs index cfaa8d87bf4..4ddea7d62c8 100644 --- a/components/layout/fragment.rs +++ b/components/layout/fragment.rs @@ -6,7 +6,7 @@ #![deny(unsafe_code)] -use canvas::canvas_paint_task::CanvasMsg; +use canvas::canvas_msg::CanvasMsg; use css::node_style::StyledNode; use context::LayoutContext; use floats::ClearType; diff --git a/components/layout/wrapper.rs b/components/layout/wrapper.rs index e528553bbc2..d1e92547bb9 100644 --- a/components/layout/wrapper.rs +++ b/components/layout/wrapper.rs @@ -32,7 +32,7 @@ #![allow(unsafe_code)] -use canvas::canvas_paint_task::CanvasMsg; +use canvas::canvas_msg::CanvasMsg; use context::SharedLayoutContext; use css::node_style::StyledNode; use incremental::RestyleDamage; diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs index f19b32242ae..f21d23cd073 100644 --- a/components/script/dom/canvasrenderingcontext2d.rs +++ b/components/script/dom/canvasrenderingcontext2d.rs @@ -27,7 +27,8 @@ use geom::point::Point2D; use geom::rect::Rect; use geom::size::Size2D; -use canvas::canvas_paint_task::{CanvasMsg, CanvasPaintTask, FillOrStrokeStyle}; +use canvas::canvas_msg::{CanvasMsg, Canvas2dMsg, CanvasCommonMsg}; +use canvas::canvas_paint_task::{CanvasPaintTask, FillOrStrokeStyle}; use canvas::canvas_paint_task::{LinearGradientStyle, RadialGradientStyle}; use canvas::canvas_paint_task::{LineCapStyle, LineJoinStyle}; @@ -112,11 +113,11 @@ impl CanvasRenderingContext2D { } pub fn recreate(&self, size: Size2D<i32>) { - self.renderer.send(CanvasMsg::Recreate(size)).unwrap(); + self.renderer.send(CanvasMsg::Common(CanvasCommonMsg::Recreate(size))).unwrap(); } fn update_transform(&self) { - self.renderer.send(CanvasMsg::SetTransform(self.state.borrow().transform)).unwrap() + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetTransform(self.state.borrow().transform))).unwrap() } // It is used by DrawImage to calculate the size of the source and destination rectangles based @@ -204,16 +205,16 @@ impl CanvasRenderingContext2D { // If the source and target canvas are the same let msg = if self.canvas.root().r() == canvas { - CanvasMsg::DrawImageSelf(image_size, dest_rect, source_rect, smoothing_enabled) + CanvasMsg::Canvas2d(Canvas2dMsg::DrawImageSelf(image_size, dest_rect, source_rect, smoothing_enabled)) } else { // Source and target canvases are different let context = canvas.get_2d_context().root(); let renderer = context.r().get_renderer(); let (sender, receiver) = channel::<Vec<u8>>(); // Reads pixels from source image - renderer.send(CanvasMsg::GetImageData(source_rect, image_size, sender)).unwrap(); + renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::GetImageData(source_rect, image_size, sender))).unwrap(); let imagedata = receiver.recv().unwrap(); // Writes pixels to destination canvas - CanvasMsg::DrawImage(imagedata, source_rect.size, dest_rect, source_rect, smoothing_enabled) + CanvasMsg::Canvas2d(Canvas2dMsg::DrawImage(imagedata, source_rect.size, dest_rect, source_rect, smoothing_enabled)) }; self.renderer.send(msg).unwrap(); @@ -233,9 +234,9 @@ impl CanvasRenderingContext2D { } let smoothing_enabled = self.state.borrow().image_smoothing_enabled; - self.renderer.send(CanvasMsg::DrawImage( + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::DrawImage( image_data, image_size, dest_rect, - source_rect, smoothing_enabled)).unwrap(); + source_rect, smoothing_enabled))).unwrap(); Ok(()) } @@ -337,7 +338,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> // https://html.spec.whatwg.org/multipage/#dom-context-2d-save fn Save(self) { self.saved_states.borrow_mut().push(self.state.borrow().clone()); - self.renderer.send(CanvasMsg::SaveContext).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SaveContext)).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-restore @@ -345,7 +346,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> let mut saved_states = self.saved_states.borrow_mut(); if let Some(state) = saved_states.pop() { self.state.borrow_mut().clone_from(&state); - self.renderer.send(CanvasMsg::RestoreContext).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::RestoreContext)).unwrap(); } } @@ -417,48 +418,48 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> } self.state.borrow_mut().global_alpha = alpha; - self.renderer.send(CanvasMsg::SetGlobalAlpha(alpha as f32)).unwrap() + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetGlobalAlpha(alpha as f32))).unwrap() } // https://html.spec.whatwg.org/multipage/#dom-context-2d-fillrect fn FillRect(self, x: f64, y: f64, width: f64, height: f64) { if let Some(rect) = self.create_drawable_rect(x, y, width, height) { - self.renderer.send(CanvasMsg::FillRect(rect)).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::FillRect(rect))).unwrap(); } } // https://html.spec.whatwg.org/multipage/#dom-context-2d-clearrect fn ClearRect(self, x: f64, y: f64, width: f64, height: f64) { if let Some(rect) = self.create_drawable_rect(x, y, width, height) { - self.renderer.send(CanvasMsg::ClearRect(rect)).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::ClearRect(rect))).unwrap(); } } // https://html.spec.whatwg.org/multipage/#dom-context-2d-strokerect fn StrokeRect(self, x: f64, y: f64, width: f64, height: f64) { if let Some(rect) = self.create_drawable_rect(x, y, width, height) { - self.renderer.send(CanvasMsg::StrokeRect(rect)).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::StrokeRect(rect))).unwrap(); } } // https://html.spec.whatwg.org/multipage/#dom-context-2d-beginpath fn BeginPath(self) { - self.renderer.send(CanvasMsg::BeginPath).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::BeginPath)).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-closepath fn ClosePath(self) { - self.renderer.send(CanvasMsg::ClosePath).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::ClosePath)).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-fill fn Fill(self, _: CanvasWindingRule) { - self.renderer.send(CanvasMsg::Fill).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Fill)).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-stroke fn Stroke(self) { - self.renderer.send(CanvasMsg::Stroke).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Stroke)).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-drawimage @@ -627,7 +628,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return; } - self.renderer.send(CanvasMsg::MoveTo(Point2D(x as f32, y as f32))).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::MoveTo(Point2D(x as f32, y as f32)))).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-lineto @@ -636,7 +637,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return; } - self.renderer.send(CanvasMsg::LineTo(Point2D(x as f32, y as f32))).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::LineTo(Point2D(x as f32, y as f32)))).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-quadraticcurveto @@ -646,8 +647,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return; } - self.renderer.send(CanvasMsg::QuadraticCurveTo(Point2D(cpx as f32, cpy as f32), - Point2D(x as f32, y as f32))).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::QuadraticCurveTo(Point2D(cpx as f32, cpy as f32), + Point2D(x as f32, y as f32)))).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-beziercurveto @@ -657,9 +658,9 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return; } - self.renderer.send(CanvasMsg::BezierCurveTo(Point2D(cp1x as f32, cp1y as f32), - Point2D(cp2x as f32, cp2y as f32), - Point2D(x as f32, y as f32))).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::BezierCurveTo(Point2D(cp1x as f32, cp1y as f32), + Point2D(cp2x as f32, cp2y as f32), + Point2D(x as f32, y as f32)))).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-arc @@ -675,8 +676,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return Err(IndexSize); } - self.renderer.send(CanvasMsg::Arc(Point2D(x as f32, y as f32), r as f32, - start as f32, end as f32, ccw)).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Arc(Point2D(x as f32, y as f32), r as f32, + start as f32, end as f32, ccw))).unwrap(); Ok(()) } @@ -688,9 +689,9 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> if r < 0.0 { return Err(IndexSize); } - self.renderer.send(CanvasMsg::ArcTo(Point2D(cp1x as f32, cp1y as f32), - Point2D(cp2x as f32, cp2y as f32), - r as f32)).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::ArcTo(Point2D(cp1x as f32, cp1y as f32), + Point2D(cp2x as f32, cp2y as f32), + r as f32))).unwrap(); Ok(()) } @@ -723,7 +724,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> Ok(rgba) => { self.state.borrow_mut().stroke_color = rgba; self.renderer - .send(CanvasMsg::SetStrokeStyle(FillOrStrokeStyle::Color(rgba))) + .send(CanvasMsg::Canvas2d(Canvas2dMsg::SetStrokeStyle(FillOrStrokeStyle::Color(rgba)))) .unwrap(); } _ => {} @@ -753,14 +754,14 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> Ok(rgba) => { self.state.borrow_mut().fill_color = rgba; self.renderer - .send(CanvasMsg::SetFillStyle(FillOrStrokeStyle::Color(rgba))) + .send(CanvasMsg::Canvas2d(Canvas2dMsg::SetFillStyle(FillOrStrokeStyle::Color(rgba)))) .unwrap() } _ => {} } } StringOrCanvasGradientOrCanvasPattern::eCanvasGradient(gradient) => { - self.renderer.send(CanvasMsg::SetFillStyle(gradient.root().r().to_fill_or_stroke_style())).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetFillStyle(gradient.root().r().to_fill_or_stroke_style()))).unwrap(); } _ => {} } @@ -799,7 +800,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> let dest_rect = Rect(Point2D(sx as f64, sy as f64), Size2D(sw as f64, sh as f64)); let canvas_size = self.canvas.root().r().get_size(); let canvas_size = Size2D(canvas_size.width as f64, canvas_size.height as f64); - self.renderer.send(CanvasMsg::GetImageData(dest_rect, canvas_size, sender)).unwrap(); + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::GetImageData(dest_rect, canvas_size, sender))).unwrap(); let data = receiver.recv().unwrap(); Ok(ImageData::new(self.global.root().r(), sw.abs().to_u32().unwrap(), sh.abs().to_u32().unwrap(), Some(data))) } @@ -820,7 +821,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> let image_data_size = Size2D(image_data_size.width as f64, image_data_size.height as f64); let image_data_rect = Rect(Point2D(dx, dy), image_data_size); let dirty_rect = None; - self.renderer.send(CanvasMsg::PutImageData(data, image_data_rect, dirty_rect)).unwrap() + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect))).unwrap() } // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata @@ -845,7 +846,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> imagedata.Height() as f64)); let dirty_rect = Some(Rect(Point2D(dirtyX, dirtyY), Size2D(dirtyWidth, dirtyHeight))); - self.renderer.send(CanvasMsg::PutImageData(data, image_data_rect, dirty_rect)).unwrap() + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect))).unwrap() } // https://html.spec.whatwg.org/multipage/#dom-context-2d-createlineargradient @@ -893,7 +894,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> } self.state.borrow_mut().line_width = width; - self.renderer.send(CanvasMsg::SetLineWidth(width as f32)).unwrap() + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetLineWidth(width as f32))).unwrap() } // https://html.spec.whatwg.org/multipage/#dom-context-2d-linecap @@ -910,7 +911,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> fn SetLineCap(self, cap_str: DOMString) { if let Some(cap) = LineCapStyle::from_str(&cap_str) { self.state.borrow_mut().line_cap = cap; - self.renderer.send(CanvasMsg::SetLineCap(cap)).unwrap() + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetLineCap(cap))).unwrap() } } @@ -928,7 +929,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> fn SetLineJoin(self, join_str: DOMString) { if let Some(join) = LineJoinStyle::from_str(&join_str) { self.state.borrow_mut().line_join = join; - self.renderer.send(CanvasMsg::SetLineJoin(join)).unwrap() + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetLineJoin(join))).unwrap() } } @@ -945,14 +946,14 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> } self.state.borrow_mut().miter_limit = limit; - self.renderer.send(CanvasMsg::SetMiterLimit(limit as f32)).unwrap() + self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::SetMiterLimit(limit as f32))).unwrap() } } #[unsafe_destructor] impl Drop for CanvasRenderingContext2D { fn drop(&mut self) { - self.renderer.send(CanvasMsg::Close).unwrap(); + self.renderer.send(CanvasMsg::Common(CanvasCommonMsg::Close)).unwrap(); } } diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs index e4fc68565a3..0a30989442b 100644 --- a/components/script/dom/htmlcanvaselement.rs +++ b/components/script/dom/htmlcanvaselement.rs @@ -2,15 +2,17 @@ * 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/. */ -use canvas::canvas_paint_task::CanvasMsg; +use canvas::canvas_msg::CanvasMsg; use dom::attr::Attr; use dom::attr::AttrHelpers; use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding; use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding::HTMLCanvasElementMethods; use dom::bindings::codegen::InheritTypes::HTMLCanvasElementDerived; use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast}; +use dom::bindings::codegen::UnionTypes::CanvasRenderingContext2DOrWebGLRenderingContext; use dom::bindings::global::GlobalRef; -use dom::bindings::js::{MutNullableJS, JSRef, LayoutJS, Temporary}; +use dom::bindings::js::{MutNullableJS, JSRef, LayoutJS, Temporary, Unrooted}; +use dom::bindings::utils::{Reflectable}; use dom::canvasrenderingcontext2d::{CanvasRenderingContext2D, LayoutCanvasRenderingContext2DHelpers}; use dom::document::Document; use dom::element::{Element, AttributeHandlers}; @@ -19,6 +21,7 @@ use dom::element::ElementTypeId; use dom::htmlelement::{HTMLElement, HTMLElementTypeId}; use dom::node::{Node, NodeTypeId, window_from_node}; use dom::virtualmethods::VirtualMethods; +use dom::webglrenderingcontext::{WebGLRenderingContext, LayoutCanvasWebGLRenderingContextHelpers}; use util::str::{DOMString, parse_unsigned_integer}; @@ -34,7 +37,8 @@ const DEFAULT_HEIGHT: u32 = 150; #[dom_struct] pub struct HTMLCanvasElement { htmlelement: HTMLElement, - context: MutNullableJS<CanvasRenderingContext2D>, + context_2d: MutNullableJS<CanvasRenderingContext2D>, + context_webgl: MutNullableJS<WebGLRenderingContext>, width: Cell<u32>, height: Cell<u32>, } @@ -49,7 +53,8 @@ impl HTMLCanvasElement { fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLCanvasElement { HTMLCanvasElement { htmlelement: HTMLElement::new_inherited(HTMLElementTypeId::HTMLCanvasElement, localName, prefix, document), - context: Default::default(), + context_2d: Default::default(), + context_webgl: Default::default(), width: Cell::new(DEFAULT_WIDTH), height: Cell::new(DEFAULT_HEIGHT), } @@ -60,6 +65,20 @@ impl HTMLCanvasElement { let element = HTMLCanvasElement::new_inherited(localName, prefix, document); Node::reflect_node(box element, document, HTMLCanvasElementBinding::Wrap) } + + fn recreate_contexts(&self) { + let size = self.get_size(); + if let Some(context) = self.context_2d.get() { + context.root().r().recreate(size) + } + if let Some(context) = self.context_webgl.get() { + context.root().r().recreate(size) + } + } + + pub fn get_size(&self) -> Size2D<i32> { + Size2D(self.width.get() as i32, self.height.get() as i32) + } } pub trait LayoutHTMLCanvasElementHelpers { @@ -74,8 +93,16 @@ pub trait LayoutHTMLCanvasElementHelpers { impl LayoutHTMLCanvasElementHelpers for LayoutJS<HTMLCanvasElement> { #[allow(unsafe_code)] unsafe fn get_renderer(&self) -> Option<Sender<CanvasMsg>> { - let context = (*self.unsafe_get()).context.get_inner_as_layout(); - context.map(|cx| cx.get_renderer()) + let ref canvas = *self.unsafe_get(); + if canvas.context_2d.get().is_some() { + let context = canvas.context_2d.get_inner_as_layout(); + context.map(|cx| cx.get_renderer()) + } else if canvas.context_webgl.get().is_some() { + let context = canvas.context_webgl.get_inner_as_layout(); + context.map(|cx| cx.get_renderer()) + } else { + None + } } #[allow(unsafe_code)] @@ -90,18 +117,30 @@ impl LayoutHTMLCanvasElementHelpers for LayoutJS<HTMLCanvasElement> { } pub trait HTMLCanvasElementHelpers { - fn get_size(&self) -> Size2D<i32>; fn get_2d_context(self) -> Temporary<CanvasRenderingContext2D>; + fn get_webgl_context(self) -> Temporary<WebGLRenderingContext>; fn is_valid(self) -> bool; } impl<'a> HTMLCanvasElementHelpers for JSRef<'a, HTMLCanvasElement> { - fn get_size(&self) -> Size2D<i32> { - Size2D(self.Width() as i32, self.Height() as i32) + fn get_2d_context(self) -> Temporary<CanvasRenderingContext2D> { + let context = self.GetContext(String::from_str("2d")); + match context.unwrap() { + CanvasRenderingContext2DOrWebGLRenderingContext::eCanvasRenderingContext2D(context) => { + Temporary::new(context.root().r().unrooted()) + } + _ => panic!("Wrong Context Type: Expected 2d context"), + } } - fn get_2d_context(self) -> Temporary<CanvasRenderingContext2D> { - self.GetContext(String::from_str("2d")).unwrap() + fn get_webgl_context(self) -> Temporary<WebGLRenderingContext> { + let context = self.GetContext(String::from_str("webgl")); + match context.unwrap() { + CanvasRenderingContext2DOrWebGLRenderingContext::eWebGLRenderingContext(context) => { + return Temporary::new(context.root().r().unrooted()); + } + _ => panic!("Wrong Context Type: Expected webgl context"), + } } fn is_valid(self) -> bool { @@ -128,17 +167,27 @@ impl<'a> HTMLCanvasElementMethods for JSRef<'a, HTMLCanvasElement> { elem.set_uint_attribute(&atom!("height"), height) } - fn GetContext(self, id: DOMString) -> Option<Temporary<CanvasRenderingContext2D>> { - if id.as_slice() != "2d" { - return None; - } - - Some(self.context.or_init(|| { - let window = window_from_node(self).root(); - let (w, h) = (self.width.get() as i32, self.height.get() as i32); - CanvasRenderingContext2D::new(GlobalRef::Window(window.r()), self, Size2D(w, h)) - })) - } + fn GetContext(self, id: DOMString) -> Option<CanvasRenderingContext2DOrWebGLRenderingContext> { + match id.as_slice() { + "2d" => { + let context_2d = self.context_2d.or_init(|| { + let window = window_from_node(self).root(); + let size = self.get_size(); + CanvasRenderingContext2D::new(GlobalRef::Window(window.r()), self, size) + }); + Some(CanvasRenderingContext2DOrWebGLRenderingContext::eCanvasRenderingContext2D(Unrooted::from_temporary(context_2d))) + } + "webgl" | "experimental-webgl" => { + let context_webgl = self.context_webgl.or_init(|| { + let window = window_from_node(self).root(); + let size = self.get_size(); + WebGLRenderingContext::new(GlobalRef::Window(window.r()), self, size) + }); + Some(CanvasRenderingContext2DOrWebGLRenderingContext::eWebGLRenderingContext(Unrooted::from_temporary(context_webgl))) + } + _ => return None + } + } } impl<'a> VirtualMethods for JSRef<'a, HTMLCanvasElement> { @@ -165,11 +214,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLCanvasElement> { }; if recreate { - let (w, h) = (self.width.get() as i32, self.height.get() as i32); - match self.context.get() { - Some(context) => context.root().r().recreate(Size2D(w, h)), - None => () - } + self.recreate_contexts(); } } @@ -192,12 +237,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLCanvasElement> { }; if recreate { - let (w, h) = (self.width.get() as i32, self.height.get() as i32); - match self.context.get() { - Some(context) => context.root().r().recreate(Size2D(w, h)), - None => () - } + self.recreate_contexts(); } } } - diff --git a/components/script/dom/mod.rs b/components/script/dom/mod.rs index 6c7204f7765..9f33d5ec195 100644 --- a/components/script/dom/mod.rs +++ b/components/script/dom/mod.rs @@ -324,6 +324,7 @@ pub mod urlsearchparams; pub mod userscripts; pub mod validitystate; pub mod virtualmethods; +pub mod webglrenderingcontext; pub mod websocket; pub mod window; pub mod worker; diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs new file mode 100644 index 00000000000..07c47970476 --- /dev/null +++ b/components/script/dom/webglrenderingcontext.rs @@ -0,0 +1,75 @@ +/* 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/. */ + +use canvas::webgl_paint_task::WebGLPaintTask; +use canvas::canvas_msg::{CanvasMsg, CanvasWebGLMsg, CanvasCommonMsg}; +use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding; +use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextMethods; +use dom::bindings::global::{GlobalRef, GlobalField}; +use dom::bindings::js::{JS, JSRef, LayoutJS, Temporary}; +use dom::bindings::utils::{Reflector, reflect_dom_object}; +use dom::htmlcanvaselement::{HTMLCanvasElement}; +use geom::size::Size2D; +use std::sync::mpsc::{Sender}; + +#[dom_struct] +pub struct WebGLRenderingContext { + reflector_: Reflector, + global: GlobalField, + renderer: Sender<CanvasMsg>, + canvas: JS<HTMLCanvasElement>, +} + +impl WebGLRenderingContext { + fn new_inherited(global: GlobalRef, canvas: JSRef<HTMLCanvasElement>, size: Size2D<i32>) + -> WebGLRenderingContext { + WebGLRenderingContext { + reflector_: Reflector::new(), + global: GlobalField::from_rooted(&global), + renderer: WebGLPaintTask::start(size), + canvas: JS::from_rooted(canvas), + } + } + + pub fn new(global: GlobalRef, canvas: JSRef<HTMLCanvasElement>, size: Size2D<i32>) + -> Temporary<WebGLRenderingContext> { + reflect_dom_object(box WebGLRenderingContext::new_inherited(global, canvas, size), + global, WebGLRenderingContextBinding::Wrap) + } + + pub fn recreate(&self, size: Size2D<i32>) { + self.renderer.send(CanvasMsg::Common(CanvasCommonMsg::Recreate(size))).unwrap(); + } + +} + +#[unsafe_destructor] +impl Drop for WebGLRenderingContext { + fn drop(&mut self) { + self.renderer.send(CanvasMsg::Common(CanvasCommonMsg::Close)).unwrap(); + } +} + +impl<'a> WebGLRenderingContextMethods for JSRef<'a, WebGLRenderingContext> { + fn Clear(self, mask: u32) -> () { + self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::Clear(mask))).unwrap() + } + + fn ClearColor(self, red: f32, green: f32, blue: f32, alpha: f32) -> (){ + self.renderer.send(CanvasMsg::WebGL(CanvasWebGLMsg::ClearColor(red, green, blue, alpha))).unwrap() + } +} + +pub trait LayoutCanvasWebGLRenderingContextHelpers { + #[allow(unsafe_code)] + unsafe fn get_renderer(&self) -> Sender<CanvasMsg>; +} + +impl LayoutCanvasWebGLRenderingContextHelpers for LayoutJS<WebGLRenderingContext> { + #[allow(unsafe_code)] + unsafe fn get_renderer(&self) -> Sender<CanvasMsg> { + (*self.unsafe_get()).renderer.clone() + } +} + diff --git a/components/script/dom/webidls/HTMLCanvasElement.webidl b/components/script/dom/webidls/HTMLCanvasElement.webidl index e1192d215f8..2458ce41a1f 100644 --- a/components/script/dom/webidls/HTMLCanvasElement.webidl +++ b/components/script/dom/webidls/HTMLCanvasElement.webidl @@ -3,8 +3,8 @@ * 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.whatwg.org/html/#htmlcanvaselement -//typedef (CanvasRenderingContext2D or WebGLRenderingContext) RenderingContext; +// https://www.whatwg.org/html/#htmlcanvaselement +typedef (CanvasRenderingContext2D or WebGLRenderingContext) RenderingContext; interface HTMLCanvasElement : HTMLElement { [Pure] @@ -12,8 +12,7 @@ interface HTMLCanvasElement : HTMLElement { [Pure] attribute unsigned long height; - //RenderingContext? getContext(DOMString contextId, any... arguments); - CanvasRenderingContext2D? getContext(DOMString contextId); + RenderingContext? getContext(DOMString contextId); //boolean probablySupportsContext(DOMString contextId, any... arguments); //void setContext(RenderingContext context); diff --git a/components/script/dom/webidls/WebGLRenderingContext.webidl b/components/script/dom/webidls/WebGLRenderingContext.webidl new file mode 100644 index 00000000000..aa1d3535635 --- /dev/null +++ b/components/script/dom/webidls/WebGLRenderingContext.webidl @@ -0,0 +1,739 @@ +// AUTOGENERATED FILE -- DO NOT EDIT -- SEE Makefile +// +// WebGL IDL definitions scraped from the Khronos specification: +// https://www.khronos.org/registry/webgl/specs/latest/ +// +// This IDL depends on the typed array specification defined at: +// https://www.khronos.org/registry/typedarray/specs/latest/typedarrays.idl + +typedef unsigned long GLenum; +typedef boolean GLboolean; +typedef unsigned long GLbitfield; +typedef byte GLbyte; /* 'byte' should be a signed 8 bit type. */ +typedef short GLshort; +typedef long GLint; +typedef long GLsizei; +typedef long long GLintptr; +typedef long long GLsizeiptr; +// Ideally the typedef below would use 'unsigned byte', but that doesn't currently exist in Web IDL. +typedef octet GLubyte; /* 'octet' should be an unsigned 8 bit type. */ +typedef unsigned short GLushort; +typedef unsigned long GLuint; +typedef unrestricted float GLfloat; +typedef unrestricted float GLclampf; + + +dictionary WebGLContextAttributes { + GLboolean alpha = true; + GLboolean depth = true; + GLboolean stencil = false; + GLboolean antialias = true; + GLboolean premultipliedAlpha = true; + GLboolean preserveDrawingBuffer = false; + GLboolean preferLowPowerToHighPerformance = false; + GLboolean failIfMajorPerformanceCaveat = false; +}; + +//interface WebGLObject { +//}; + +//interface WebGLBuffer : WebGLObject { +//}; + +//interface WebGLFramebuffer : WebGLObject { +//}; + +//interface WebGLProgram : WebGLObject { +//}; + +//interface WebGLRenderbuffer : WebGLObject { +//}; + +//interface WebGLShader : WebGLObject { +//}; + +//interface WebGLTexture : WebGLObject { +//}; + +//interface WebGLUniformLocation { +//}; + +//interface WebGLActiveInfo { +// readonly attribute GLint size; +// readonly attribute GLenum type; +// readonly attribute DOMString name; +//}; + +//interface WebGLShaderPrecisionFormat { +// readonly attribute GLint rangeMin; +// readonly attribute GLint rangeMax; +// readonly attribute GLint precision; +//}; + +[NoInterfaceObject] +interface WebGLRenderingContextBase +{ + + /* ClearBufferMask */ + //const GLenum DEPTH_BUFFER_BIT = 0x00000100; + //const GLenum STENCIL_BUFFER_BIT = 0x00000400; + const GLenum COLOR_BUFFER_BIT = 0x00004000; + + /* BeginMode */ + //const GLenum POINTS = 0x0000; + //const GLenum LINES = 0x0001; + //const GLenum LINE_LOOP = 0x0002; + //const GLenum LINE_STRIP = 0x0003; + //const GLenum TRIANGLES = 0x0004; + //const GLenum TRIANGLE_STRIP = 0x0005; + //const GLenum TRIANGLE_FAN = 0x0006; + + /* AlphaFunction (not supported in ES20) */ + /* NEVER */ + /* LESS */ + /* EQUAL */ + /* LEQUAL */ + /* GREATER */ + /* NOTEQUAL */ + /* GEQUAL */ + /* ALWAYS */ + + /* BlendingFactorDest */ + //const GLenum ZERO = 0; + //const GLenum ONE = 1; + //const GLenum SRC_COLOR = 0x0300; + //const GLenum ONE_MINUS_SRC_COLOR = 0x0301; + //const GLenum SRC_ALPHA = 0x0302; + //const GLenum ONE_MINUS_SRC_ALPHA = 0x0303; + //const GLenum DST_ALPHA = 0x0304; + //const GLenum ONE_MINUS_DST_ALPHA = 0x0305; + + /* BlendingFactorSrc */ + /* ZERO */ + /* ONE */ + //const GLenum DST_COLOR = 0x0306; + //const GLenum ONE_MINUS_DST_COLOR = 0x0307; + //const GLenum SRC_ALPHA_SATURATE = 0x0308; + /* SRC_ALPHA */ + /* ONE_MINUS_SRC_ALPHA */ + /* DST_ALPHA */ + /* ONE_MINUS_DST_ALPHA */ + + /* BlendEquationSeparate */ + //const GLenum FUNC_ADD = 0x8006; + //const GLenum BLEND_EQUATION = 0x8009; + //const GLenum BLEND_EQUATION_RGB = 0x8009; /* same as BLEND_EQUATION */ + //const GLenum BLEND_EQUATION_ALPHA = 0x883D; + + /* BlendSubtract */ + //const GLenum FUNC_SUBTRACT = 0x800A; + //const GLenum FUNC_REVERSE_SUBTRACT = 0x800B; + + /* Separate Blend Functions */ + //const GLenum BLEND_DST_RGB = 0x80C8; + //const GLenum BLEND_SRC_RGB = 0x80C9; + //const GLenum BLEND_DST_ALPHA = 0x80CA; + //const GLenum BLEND_SRC_ALPHA = 0x80CB; + //const GLenum CONSTANT_COLOR = 0x8001; + //const GLenum ONE_MINUS_CONSTANT_COLOR = 0x8002; + //const GLenum CONSTANT_ALPHA = 0x8003; + //const GLenum ONE_MINUS_CONSTANT_ALPHA = 0x8004; + //const GLenum BLEND_COLOR = 0x8005; + + /* Buffer Objects */ + //const GLenum ARRAY_BUFFER = 0x8892; + //const GLenum ELEMENT_ARRAY_BUFFER = 0x8893; + //const GLenum ARRAY_BUFFER_BINDING = 0x8894; + //const GLenum ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; + + //const GLenum STREAM_DRAW = 0x88E0; + //const GLenum STATIC_DRAW = 0x88E4; + //const GLenum DYNAMIC_DRAW = 0x88E8; + + //const GLenum BUFFER_SIZE = 0x8764; + //const GLenum BUFFER_USAGE = 0x8765; + + //const GLenum CURRENT_VERTEX_ATTRIB = 0x8626; + + /* CullFaceMode */ + //const GLenum FRONT = 0x0404; + //const GLenum BACK = 0x0405; + //const GLenum FRONT_AND_BACK = 0x0408; + + /* DepthFunction */ + /* NEVER */ + /* LESS */ + /* EQUAL */ + /* LEQUAL */ + /* GREATER */ + /* NOTEQUAL */ + /* GEQUAL */ + /* ALWAYS */ + + /* EnableCap */ + /* TEXTURE_2D */ + //const GLenum CULL_FACE = 0x0B44; + //const GLenum BLEND = 0x0BE2; + //const GLenum DITHER = 0x0BD0; + //const GLenum STENCIL_TEST = 0x0B90; + //const GLenum DEPTH_TEST = 0x0B71; + //const GLenum SCISSOR_TEST = 0x0C11; + //const GLenum POLYGON_OFFSET_FILL = 0x8037; + //const GLenum SAMPLE_ALPHA_TO_COVERAGE = 0x809E; + //const GLenum SAMPLE_COVERAGE = 0x80A0; + + /* ErrorCode */ + //const GLenum NO_ERROR = 0; + //const GLenum INVALID_ENUM = 0x0500; + //const GLenum INVALID_VALUE = 0x0501; + //const GLenum INVALID_OPERATION = 0x0502; + //const GLenum OUT_OF_MEMORY = 0x0505; + + /* FrontFaceDirection */ + //const GLenum CW = 0x0900; + //const GLenum CCW = 0x0901; + + /* GetPName */ + //const GLenum LINE_WIDTH = 0x0B21; + //const GLenum ALIASED_POINT_SIZE_RANGE = 0x846D; + //const GLenum ALIASED_LINE_WIDTH_RANGE = 0x846E; + //const GLenum CULL_FACE_MODE = 0x0B45; + //const GLenum FRONT_FACE = 0x0B46; + //const GLenum DEPTH_RANGE = 0x0B70; + //const GLenum DEPTH_WRITEMASK = 0x0B72; + //const GLenum DEPTH_CLEAR_VALUE = 0x0B73; + //const GLenum DEPTH_FUNC = 0x0B74; + //const GLenum STENCIL_CLEAR_VALUE = 0x0B91; + //const GLenum STENCIL_FUNC = 0x0B92; + //const GLenum STENCIL_FAIL = 0x0B94; + //const GLenum STENCIL_PASS_DEPTH_FAIL = 0x0B95; + //const GLenum STENCIL_PASS_DEPTH_PASS = 0x0B96; + //const GLenum STENCIL_REF = 0x0B97; + //const GLenum STENCIL_VALUE_MASK = 0x0B93; + //const GLenum STENCIL_WRITEMASK = 0x0B98; + //const GLenum STENCIL_BACK_FUNC = 0x8800; + //const GLenum STENCIL_BACK_FAIL = 0x8801; + //const GLenum STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; + //const GLenum STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; + //const GLenum STENCIL_BACK_REF = 0x8CA3; + //const GLenum STENCIL_BACK_VALUE_MASK = 0x8CA4; + //const GLenum STENCIL_BACK_WRITEMASK = 0x8CA5; + //const GLenum VIEWPORT = 0x0BA2; + //const GLenum SCISSOR_BOX = 0x0C10; + /* SCISSOR_TEST */ + //const GLenum COLOR_CLEAR_VALUE = 0x0C22; + //const GLenum COLOR_WRITEMASK = 0x0C23; + //const GLenum UNPACK_ALIGNMENT = 0x0CF5; + //const GLenum PACK_ALIGNMENT = 0x0D05; + //const GLenum MAX_TEXTURE_SIZE = 0x0D33; + //const GLenum MAX_VIEWPORT_DIMS = 0x0D3A; + //const GLenum SUBPIXEL_BITS = 0x0D50; + //const GLenum RED_BITS = 0x0D52; + //const GLenum GREEN_BITS = 0x0D53; + //const GLenum BLUE_BITS = 0x0D54; + //const GLenum ALPHA_BITS = 0x0D55; + //const GLenum DEPTH_BITS = 0x0D56; + //const GLenum STENCIL_BITS = 0x0D57; + //const GLenum POLYGON_OFFSET_UNITS = 0x2A00; + /* POLYGON_OFFSET_FILL */ + //const GLenum POLYGON_OFFSET_FACTOR = 0x8038; + //const GLenum TEXTURE_BINDING_2D = 0x8069; + //const GLenum SAMPLE_BUFFERS = 0x80A8; + //const GLenum SAMPLES = 0x80A9; + //const GLenum SAMPLE_COVERAGE_VALUE = 0x80AA; + //const GLenum SAMPLE_COVERAGE_INVERT = 0x80AB; + + /* GetTextureParameter */ + /* TEXTURE_MAG_FILTER */ + /* TEXTURE_MIN_FILTER */ + /* TEXTURE_WRAP_S */ + /* TEXTURE_WRAP_T */ + + //const GLenum COMPRESSED_TEXTURE_FORMATS = 0x86A3; + + /* HintMode */ + //const GLenum DONT_CARE = 0x1100; + //const GLenum FASTEST = 0x1101; + //const GLenum NICEST = 0x1102; + + /* HintTarget */ + //const GLenum GENERATE_MIPMAP_HINT = 0x8192; + + /* DataType */ + //const GLenum BYTE = 0x1400; + //const GLenum UNSIGNED_BYTE = 0x1401; + //const GLenum SHORT = 0x1402; + //const GLenum UNSIGNED_SHORT = 0x1403; + //const GLenum INT = 0x1404; + //const GLenum UNSIGNED_INT = 0x1405; + //const GLenum FLOAT = 0x1406; + + /* PixelFormat */ + //const GLenum DEPTH_COMPONENT = 0x1902; + //const GLenum ALPHA = 0x1906; + //const GLenum RGB = 0x1907; + //const GLenum RGBA = 0x1908; + //const GLenum LUMINANCE = 0x1909; + //const GLenum LUMINANCE_ALPHA = 0x190A; + + /* PixelType */ + /* UNSIGNED_BYTE */ + //const GLenum UNSIGNED_SHORT_4_4_4_4 = 0x8033; + //const GLenum UNSIGNED_SHORT_5_5_5_1 = 0x8034; + //const GLenum UNSIGNED_SHORT_5_6_5 = 0x8363; + + /* Shaders */ + //const GLenum FRAGMENT_SHADER = 0x8B30; + //const GLenum VERTEX_SHADER = 0x8B31; + //const GLenum MAX_VERTEX_ATTRIBS = 0x8869; + //const GLenum MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB; + //const GLenum MAX_VARYING_VECTORS = 0x8DFC; + //const GLenum MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; + //const GLenum MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; + //const GLenum MAX_TEXTURE_IMAGE_UNITS = 0x8872; + //const GLenum MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD; + //const GLenum SHADER_TYPE = 0x8B4F; + //const GLenum DELETE_STATUS = 0x8B80; + //const GLenum LINK_STATUS = 0x8B82; + //const GLenum VALIDATE_STATUS = 0x8B83; + //const GLenum ATTACHED_SHADERS = 0x8B85; + //const GLenum ACTIVE_UNIFORMS = 0x8B86; + //const GLenum ACTIVE_ATTRIBUTES = 0x8B89; + //const GLenum SHADING_LANGUAGE_VERSION = 0x8B8C; + //const GLenum CURRENT_PROGRAM = 0x8B8D; + + /* StencilFunction */ + //const GLenum NEVER = 0x0200; + //const GLenum LESS = 0x0201; + //const GLenum EQUAL = 0x0202; + //const GLenum LEQUAL = 0x0203; + //const GLenum GREATER = 0x0204; + //const GLenum NOTEQUAL = 0x0205; + //const GLenum GEQUAL = 0x0206; + //const GLenum ALWAYS = 0x0207; + + /* StencilOp */ + /* ZERO */ + //const GLenum KEEP = 0x1E00; + //const GLenum REPLACE = 0x1E01; + //const GLenum INCR = 0x1E02; + //const GLenum DECR = 0x1E03; + //const GLenum INVERT = 0x150A; + //const GLenum INCR_WRAP = 0x8507; + //const GLenum DECR_WRAP = 0x8508; + + /* StringName */ + //const GLenum VENDOR = 0x1F00; + //const GLenum RENDERER = 0x1F01; + //const GLenum VERSION = 0x1F02; + + /* TextureMagFilter */ + //const GLenum NEAREST = 0x2600; + //const GLenum LINEAR = 0x2601; + + /* TextureMinFilter */ + /* NEAREST */ + /* LINEAR */ + //const GLenum NEAREST_MIPMAP_NEAREST = 0x2700; + //const GLenum LINEAR_MIPMAP_NEAREST = 0x2701; + //const GLenum NEAREST_MIPMAP_LINEAR = 0x2702; + //const GLenum LINEAR_MIPMAP_LINEAR = 0x2703; + + /* TextureParameterName */ + //const GLenum TEXTURE_MAG_FILTER = 0x2800; + //const GLenum TEXTURE_MIN_FILTER = 0x2801; + //const GLenum TEXTURE_WRAP_S = 0x2802; + //const GLenum TEXTURE_WRAP_T = 0x2803; + + /* TextureTarget */ + //const GLenum TEXTURE_2D = 0x0DE1; + //const GLenum TEXTURE = 0x1702; + + //const GLenum TEXTURE_CUBE_MAP = 0x8513; + //const GLenum TEXTURE_BINDING_CUBE_MAP = 0x8514; + //const GLenum TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; + //const GLenum TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; + //const GLenum TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; + //const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; + //const GLenum TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; + //const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; + //const GLenum MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; + + /* TextureUnit */ + //const GLenum TEXTURE0 = 0x84C0; + //const GLenum TEXTURE1 = 0x84C1; + //const GLenum TEXTURE2 = 0x84C2; + //const GLenum TEXTURE3 = 0x84C3; + //const GLenum TEXTURE4 = 0x84C4; + //const GLenum TEXTURE5 = 0x84C5; + //const GLenum TEXTURE6 = 0x84C6; + //const GLenum TEXTURE7 = 0x84C7; + //const GLenum TEXTURE8 = 0x84C8; + //const GLenum TEXTURE9 = 0x84C9; + //const GLenum TEXTURE10 = 0x84CA; + //const GLenum TEXTURE11 = 0x84CB; + //const GLenum TEXTURE12 = 0x84CC; + //const GLenum TEXTURE13 = 0x84CD; + //const GLenum TEXTURE14 = 0x84CE; + //const GLenum TEXTURE15 = 0x84CF; + //const GLenum TEXTURE16 = 0x84D0; + //const GLenum TEXTURE17 = 0x84D1; + //const GLenum TEXTURE18 = 0x84D2; + //const GLenum TEXTURE19 = 0x84D3; + //const GLenum TEXTURE20 = 0x84D4; + //const GLenum TEXTURE21 = 0x84D5; + //const GLenum TEXTURE22 = 0x84D6; + //const GLenum TEXTURE23 = 0x84D7; + //const GLenum TEXTURE24 = 0x84D8; + //const GLenum TEXTURE25 = 0x84D9; + //const GLenum TEXTURE26 = 0x84DA; + //const GLenum TEXTURE27 = 0x84DB; + //const GLenum TEXTURE28 = 0x84DC; + //const GLenum TEXTURE29 = 0x84DD; + //const GLenum TEXTURE30 = 0x84DE; + //const GLenum TEXTURE31 = 0x84DF; + //const GLenum ACTIVE_TEXTURE = 0x84E0; + + /* TextureWrapMode */ + //const GLenum REPEAT = 0x2901; + //const GLenum CLAMP_TO_EDGE = 0x812F; + //const GLenum MIRRORED_REPEAT = 0x8370; + + /* Uniform Types */ + //const GLenum FLOAT_VEC2 = 0x8B50; + //const GLenum FLOAT_VEC3 = 0x8B51; + //const GLenum FLOAT_VEC4 = 0x8B52; + //const GLenum INT_VEC2 = 0x8B53; + //const GLenum INT_VEC3 = 0x8B54; + //const GLenum INT_VEC4 = 0x8B55; + //const GLenum BOOL = 0x8B56; + //const GLenum BOOL_VEC2 = 0x8B57; + //const GLenum BOOL_VEC3 = 0x8B58; + //const GLenum BOOL_VEC4 = 0x8B59; + //const GLenum FLOAT_MAT2 = 0x8B5A; + //const GLenum FLOAT_MAT3 = 0x8B5B; + //const GLenum FLOAT_MAT4 = 0x8B5C; + //const GLenum SAMPLER_2D = 0x8B5E; + //const GLenum SAMPLER_CUBE = 0x8B60; + + /* Vertex Arrays */ + //const GLenum VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; + //const GLenum VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; + //const GLenum VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; + //const GLenum VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; + //const GLenum VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; + //const GLenum VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; + //const GLenum VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; + + /* Read Format */ + //const GLenum IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A; + //const GLenum IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; + + /* Shader Source */ + //const GLenum COMPILE_STATUS = 0x8B81; + + /* Shader Precision-Specified Types */ + //const GLenum LOW_FLOAT = 0x8DF0; + //const GLenum MEDIUM_FLOAT = 0x8DF1; + //const GLenum HIGH_FLOAT = 0x8DF2; + //const GLenum LOW_INT = 0x8DF3; + //const GLenum MEDIUM_INT = 0x8DF4; + //const GLenum HIGH_INT = 0x8DF5; + + /* Framebuffer Object. */ + //const GLenum FRAMEBUFFER = 0x8D40; + //const GLenum RENDERBUFFER = 0x8D41; + + //const GLenum RGBA4 = 0x8056; + //const GLenum RGB5_A1 = 0x8057; + //const GLenum RGB565 = 0x8D62; + //const GLenum DEPTH_COMPONENT16 = 0x81A5; + //const GLenum STENCIL_INDEX = 0x1901; + //const GLenum STENCIL_INDEX8 = 0x8D48; + //const GLenum DEPTH_STENCIL = 0x84F9; + + //const GLenum RENDERBUFFER_WIDTH = 0x8D42; + //const GLenum RENDERBUFFER_HEIGHT = 0x8D43; + //const GLenum RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; + //const GLenum RENDERBUFFER_RED_SIZE = 0x8D50; + //const GLenum RENDERBUFFER_GREEN_SIZE = 0x8D51; + //const GLenum RENDERBUFFER_BLUE_SIZE = 0x8D52; + //const GLenum RENDERBUFFER_ALPHA_SIZE = 0x8D53; + //const GLenum RENDERBUFFER_DEPTH_SIZE = 0x8D54; + //const GLenum RENDERBUFFER_STENCIL_SIZE = 0x8D55; + + //const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; + //const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; + //const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; + //const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; + + //const GLenum COLOR_ATTACHMENT0 = 0x8CE0; + //const GLenum DEPTH_ATTACHMENT = 0x8D00; + //const GLenum STENCIL_ATTACHMENT = 0x8D20; + //const GLenum DEPTH_STENCIL_ATTACHMENT = 0x821A; + + //const GLenum NONE = 0; + + //const GLenum FRAMEBUFFER_COMPLETE = 0x8CD5; + //const GLenum FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; + //const GLenum FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; + //const GLenum FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9; + //const GLenum FRAMEBUFFER_UNSUPPORTED = 0x8CDD; + + //const GLenum FRAMEBUFFER_BINDING = 0x8CA6; + //const GLenum RENDERBUFFER_BINDING = 0x8CA7; + //const GLenum MAX_RENDERBUFFER_SIZE = 0x84E8; + + //const GLenum INVALID_FRAMEBUFFER_OPERATION = 0x0506; + + /* WebGL-specific enums */ + //const GLenum UNPACK_FLIP_Y_WEBGL = 0x9240; + //const GLenum UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241; + //const GLenum CONTEXT_LOST_WEBGL = 0x9242; + //const GLenum UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243; + //const GLenum BROWSER_DEFAULT_WEBGL = 0x9244; + + //readonly attribute HTMLCanvasElement canvas; + //readonly attribute GLsizei drawingBufferWidth; + //readonly attribute GLsizei drawingBufferHeight; + + //[WebGLHandlesContextLoss] WebGLContextAttributes? getContextAttributes(); + //[WebGLHandlesContextLoss] boolean isContextLost(); + + //sequence<DOMString>? getSupportedExtensions(); + //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 blendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + //void blendEquation(GLenum mode); + //void blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); + //void blendFunc(GLenum sfactor, GLenum dfactor); + //void blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, + // GLenum srcAlpha, GLenum dstAlpha); + + //typedef (ArrayBuffer or ArrayBufferView) BufferDataSource; + //void bufferData(GLenum target, GLsizeiptr size, GLenum usage); + //void bufferData(GLenum target, BufferDataSource? data, GLenum usage); + //void bufferSubData(GLenum target, GLintptr offset, BufferDataSource? data); + + //[WebGLHandlesContextLoss] GLenum checkFramebufferStatus(GLenum target); + void clear(GLbitfield mask); + void clearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + //void clearDepth(GLclampf depth); + //void clearStencil(GLint s); + //void colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); + //void compileShader(WebGLShader? shader); + + //void compressedTexImage2D(GLenum target, GLint level, GLenum internalformat, + // GLsizei width, GLsizei height, GLint border, + // ArrayBufferView data); + //void compressedTexSubImage2D(GLenum target, GLint level, + // GLint xoffset, GLint yoffset, + // GLsizei width, GLsizei height, GLenum format, + // ArrayBufferView data); + + //void copyTexImage2D(GLenum target, GLint level, GLenum internalformat, + // GLint x, GLint y, GLsizei width, GLsizei height, + // GLint border); + //void copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, + // GLint x, GLint y, GLsizei width, GLsizei height); + + //WebGLBuffer? createBuffer(); + //WebGLFramebuffer? createFramebuffer(); + //WebGLProgram? createProgram(); + //WebGLRenderbuffer? createRenderbuffer(); + //WebGLShader? createShader(GLenum type); + //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 depthFunc(GLenum func); + //void depthMask(GLboolean flag); + //void depthRange(GLclampf zNear, GLclampf zFar); + //void detachShader(WebGLProgram? program, WebGLShader? shader); + //void disable(GLenum cap); + //void disableVertexAttribArray(GLuint index); + //void drawArrays(GLenum mode, GLint first, GLsizei count); + //void drawElements(GLenum mode, GLsizei count, GLenum type, GLintptr offset); + + //void enable(GLenum cap); + //void enableVertexAttribArray(GLuint index); + //void finish(); + //void flush(); + //void framebufferRenderbuffer(GLenum target, GLenum attachment, + // GLenum renderbuffertarget, + // WebGLRenderbuffer? renderbuffer); + //void framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, + // WebGLTexture? texture, GLint level); + //void frontFace(GLenum mode); + + //void generateMipmap(GLenum target); + + //WebGLActiveInfo? getActiveAttrib(WebGLProgram? program, GLuint index); + //WebGLActiveInfo? getActiveUniform(WebGLProgram? program, GLuint index); + //sequence<WebGLShader>? getAttachedShaders(WebGLProgram? program); + + //[WebGLHandlesContextLoss] GLint getAttribLocation(WebGLProgram? program, DOMString name); + + //any getBufferParameter(GLenum target, GLenum pname); + //any getParameter(GLenum pname); + + //[WebGLHandlesContextLoss] GLenum getError(); + + //any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, + // GLenum pname); + //any getProgramParameter(WebGLProgram? program, GLenum pname); + //DOMString? getProgramInfoLog(WebGLProgram? program); + //any getRenderbufferParameter(GLenum target, GLenum pname); + //any getShaderParameter(WebGLShader? shader, GLenum pname); + //WebGLShaderPrecisionFormat? getShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype); + //DOMString? getShaderInfoLog(WebGLShader? shader); + + //DOMString? getShaderSource(WebGLShader? shader); + + //any getTexParameter(GLenum target, GLenum pname); + + //any getUniform(WebGLProgram? program, WebGLUniformLocation? location); + + //WebGLUniformLocation? getUniformLocation(WebGLProgram? program, DOMString name); + + //any getVertexAttrib(GLuint index, GLenum pname); + + //[WebGLHandlesContextLoss] GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname); + + //void hint(GLenum target, GLenum mode); + //[WebGLHandlesContextLoss] GLboolean isBuffer(WebGLBuffer? buffer); + //[WebGLHandlesContextLoss] GLboolean isEnabled(GLenum cap); + //[WebGLHandlesContextLoss] GLboolean isFramebuffer(WebGLFramebuffer? framebuffer); + //[WebGLHandlesContextLoss] GLboolean isProgram(WebGLProgram? program); + //[WebGLHandlesContextLoss] GLboolean isRenderbuffer(WebGLRenderbuffer? renderbuffer); + //[WebGLHandlesContextLoss] GLboolean isShader(WebGLShader? shader); + //[WebGLHandlesContextLoss] GLboolean isTexture(WebGLTexture? texture); + //void lineWidth(GLfloat width); + //void linkProgram(WebGLProgram? program); + //void pixelStorei(GLenum pname, GLint param); + //void polygonOffset(GLfloat factor, GLfloat units); + + //void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, + // GLenum format, GLenum type, ArrayBufferView? pixels); + + //void renderbufferStorage(GLenum target, GLenum internalformat, + // GLsizei width, GLsizei height); + //void sampleCoverage(GLclampf value, GLboolean invert); + //void scissor(GLint x, GLint y, GLsizei width, GLsizei height); + + //void shaderSource(WebGLShader? shader, DOMString source); + + //void stencilFunc(GLenum func, GLint ref, GLuint mask); + //void stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask); + //void stencilMask(GLuint mask); + //void stencilMaskSeparate(GLenum face, GLuint mask); + //void stencilOp(GLenum fail, GLenum zfail, GLenum zpass); + //void stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass); + + //typedef (ImageData or + // HTMLImageElement or + // HTMLCanvasElement or + // HTMLVideoElement) TexImageSource; + //void texImage2D(GLenum target, GLint level, GLenum internalformat, + // GLsizei width, GLsizei height, GLint border, GLenum format, + // GLenum type, ArrayBufferView? pixels); + //void texImage2D(GLenum target, GLint level, GLenum internalformat, + // GLenum format, GLenum type, TexImageSource? source); // May throw DOMException + + //void texParameterf(GLenum target, GLenum pname, GLfloat param); + //void texParameteri(GLenum target, GLenum pname, GLint param); + + //void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, + // GLsizei width, GLsizei height, + // GLenum format, GLenum type, ArrayBufferView? pixels); + //void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, + // GLenum format, GLenum type, TexImageSource? source); // May throw DOMException + + //void uniform1f(WebGLUniformLocation? location, GLfloat x); + //void uniform1fv(WebGLUniformLocation? location, Float32Array v); + //void uniform1fv(WebGLUniformLocation? location, sequence<GLfloat> v); + //void uniform1i(WebGLUniformLocation? location, GLint x); + //void uniform1iv(WebGLUniformLocation? location, Int32Array v); + //void uniform1iv(WebGLUniformLocation? location, sequence<long> v); + //void uniform2f(WebGLUniformLocation? location, GLfloat x, GLfloat y); + //void uniform2fv(WebGLUniformLocation? location, Float32Array v); + //void uniform2fv(WebGLUniformLocation? location, sequence<GLfloat> v); + //void uniform2i(WebGLUniformLocation? location, GLint x, GLint y); + //void uniform2iv(WebGLUniformLocation? location, Int32Array v); + //void uniform2iv(WebGLUniformLocation? location, sequence<long> v); + //void uniform3f(WebGLUniformLocation? location, GLfloat x, GLfloat y, GLfloat z); + //void uniform3fv(WebGLUniformLocation? location, Float32Array v); + //void uniform3fv(WebGLUniformLocation? location, sequence<GLfloat> v); + //void uniform3i(WebGLUniformLocation? location, GLint x, GLint y, GLint z); + //void uniform3iv(WebGLUniformLocation? location, Int32Array v); + //void uniform3iv(WebGLUniformLocation? location, sequence<long> v); + //void uniform4f(WebGLUniformLocation? location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + //void uniform4fv(WebGLUniformLocation? location, Float32Array v); + //void uniform4fv(WebGLUniformLocation? location, sequence<GLfloat> v); + //void uniform4i(WebGLUniformLocation? location, GLint x, GLint y, GLint z, GLint w); + //void uniform4iv(WebGLUniformLocation? location, Int32Array v); + //void uniform4iv(WebGLUniformLocation? location, sequence<long> v); + + //void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose, + // Float32Array value); + //void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose, + // sequence<GLfloat> value); + //void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose, + // Float32Array value); + //void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose, + // sequence<GLfloat> value); + //void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose, + // Float32Array value); + //void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose, + // sequence<GLfloat> value); + + //void useProgram(WebGLProgram? program); + //void validateProgram(WebGLProgram? program); + + //void vertexAttrib1f(GLuint indx, GLfloat x); + //void vertexAttrib1fv(GLuint indx, Float32Array values); + //void vertexAttrib1fv(GLuint indx, sequence<GLfloat> values); + //void vertexAttrib2f(GLuint indx, GLfloat x, GLfloat y); + //void vertexAttrib2fv(GLuint indx, Float32Array values); + //void vertexAttrib2fv(GLuint indx, sequence<GLfloat> values); + //void vertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z); + //void vertexAttrib3fv(GLuint indx, Float32Array values); + //void vertexAttrib3fv(GLuint indx, sequence<GLfloat> values); + //void vertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + //void vertexAttrib4fv(GLuint indx, Float32Array values); + //void vertexAttrib4fv(GLuint indx, sequence<GLfloat> values); + //void vertexAttribPointer(GLuint indx, GLint size, GLenum type, + // GLboolean normalized, GLsizei stride, GLintptr offset); + + //void viewport(GLint x, GLint y, GLsizei width, GLsizei height); +}; + +interface WebGLRenderingContext +{ +}; +WebGLRenderingContext implements WebGLRenderingContextBase; + + +//[Constructor(DOMString type, optional WebGLContextEventInit eventInit)] +//interface WebGLContextEvent : Event { +// readonly attribute DOMString statusMessage; +//}; + +// EventInit is defined in the DOM4 specification. +//dictionary WebGLContextEventInit : EventInit { +// DOMString statusMessage; +//}; diff --git a/components/servo/Cargo.lock b/components/servo/Cargo.lock index 3e09a9930aa..21b1955664d 100644 --- a/components/servo/Cargo.lock +++ b/components/servo/Cargo.lock @@ -61,6 +61,9 @@ dependencies = [ "cssparser 0.2.0 (git+https://github.com/servo/rust-cssparser)", "geom 0.1.0 (git+https://github.com/servo/rust-geom)", "gfx 0.0.1", + "gleam 0.0.1 (git+https://github.com/servo/gleam)", + "glutin 0.0.7 (git+https://github.com/servo/glutin?branch=servo)", + "msg 0.0.1", "util 0.0.1", ] @@ -364,7 +367,7 @@ dependencies = [ [[package]] name = "gleam" version = "0.0.1" -source = "git+https://github.com/servo/gleam#fb17a364f314a35a6d209e875b5e90a920d41e86" +source = "git+https://github.com/servo/gleam#70c5f2ea3ef3602277b7c380c24b504e42338056" dependencies = [ "gl_common 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)", "gl_generator 0.0.19 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/ports/cef/Cargo.lock b/ports/cef/Cargo.lock index bece7eec676..2e6a5fbe6ec 100644 --- a/ports/cef/Cargo.lock +++ b/ports/cef/Cargo.lock @@ -63,6 +63,9 @@ dependencies = [ "cssparser 0.2.0 (git+https://github.com/servo/rust-cssparser)", "geom 0.1.0 (git+https://github.com/servo/rust-geom)", "gfx 0.0.1", + "gleam 0.0.1 (git+https://github.com/servo/gleam)", + "glutin 0.0.7 (git+https://github.com/servo/glutin?branch=servo)", + "msg 0.0.1", "util 0.0.1", ] @@ -366,7 +369,7 @@ dependencies = [ [[package]] name = "gleam" version = "0.0.1" -source = "git+https://github.com/servo/gleam#fb17a364f314a35a6d209e875b5e90a920d41e86" +source = "git+https://github.com/servo/gleam#70c5f2ea3ef3602277b7c380c24b504e42338056" dependencies = [ "gl_common 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)", "gl_generator 0.0.19 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/ports/gonk/Cargo.lock b/ports/gonk/Cargo.lock index 3ff6432d73e..6d3715bbd7e 100644 --- a/ports/gonk/Cargo.lock +++ b/ports/gonk/Cargo.lock @@ -24,6 +24,11 @@ dependencies = [ ] [[package]] +name = "android_glue" +version = "0.0.1" +source = "git+https://github.com/tomaka/android-rs-glue#5a68056599fb498b0cf3715fd359894825e3b856" + +[[package]] name = "azure" version = "0.1.0" source = "git+https://github.com/servo/rust-azure#3e5daf667a62f702dc16285e923464458bef785f" @@ -52,6 +57,9 @@ dependencies = [ "cssparser 0.2.0 (git+https://github.com/servo/rust-cssparser)", "geom 0.1.0 (git+https://github.com/servo/rust-geom)", "gfx 0.0.1", + "gleam 0.0.1 (git+https://github.com/servo/gleam)", + "glutin 0.0.7 (git+https://github.com/servo/glutin?branch=servo)", + "msg 0.0.1", "util 0.0.1", ] @@ -69,6 +77,16 @@ version = "0.0.4" source = "git+https://github.com/tomaka/clock_ticks#6a3005279bedc406b13eea09ff92447f05ca0de6" [[package]] +name = "cocoa" +version = "0.1.1" +source = "git+https://github.com/servo/rust-cocoa#26d02e3f3606223645dde173a7bb924bce4836de" +dependencies = [ + "bitflags 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", + "objc 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] name = "compositing" version = "0.0.1" dependencies = [ @@ -279,6 +297,14 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] +name = "gdi32-sys" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "winapi 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] name = "geom" version = "0.1.0" source = "git+https://github.com/servo/rust-geom#c47fc0f927b6d6e5543fe3b5445c86810831dce1" @@ -338,7 +364,7 @@ dependencies = [ [[package]] name = "gleam" version = "0.0.1" -source = "git+https://github.com/servo/gleam#fb17a364f314a35a6d209e875b5e90a920d41e86" +source = "git+https://github.com/servo/gleam#70c5f2ea3ef3602277b7c380c24b504e42338056" dependencies = [ "gl_common 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)", "gl_generator 0.0.19 (registry+https://github.com/rust-lang/crates.io-index)", @@ -347,6 +373,25 @@ dependencies = [ ] [[package]] +name = "glutin" +version = "0.0.7" +source = "git+https://github.com/servo/glutin?branch=servo#0feab4842c5b229bfe88739d2c526d03c198fd33" +dependencies = [ + "android_glue 0.0.1 (git+https://github.com/tomaka/android-rs-glue)", + "cocoa 0.1.1 (git+https://github.com/servo/rust-cocoa)", + "core_foundation 0.1.0 (git+https://github.com/servo/rust-core-foundation)", + "core_graphics 0.1.0 (git+https://github.com/servo/rust-core-graphics)", + "gdi32-sys 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", + "gl_common 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "gl_generator 0.0.19 (registry+https://github.com/rust-lang/crates.io-index)", + "kernel32-sys 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", + "khronos_api 0.0.5 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", + "user32-sys 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", + "winapi 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] name = "glx" version = "0.0.1" source = "git+https://github.com/servo/rust-glx#f2103861d38076ef5e01a8c2f58df1e79ca12f41" @@ -424,6 +469,14 @@ dependencies = [ ] [[package]] +name = "kernel32-sys" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "winapi 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] name = "khronos_api" version = "0.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -518,6 +571,14 @@ version = "0.0.2" source = "git+https://github.com/reem/rust-mac#6316d3f4663756180fd236b126a84e245e978765" [[package]] +name = "malloc_buf" +version = "0.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "libc 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] name = "matches" version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -599,6 +660,15 @@ dependencies = [ ] [[package]] +name = "objc" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "libc 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", + "malloc_buf 0.0.5 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] name = "openssl" version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -884,6 +954,14 @@ dependencies = [ ] [[package]] +name = "user32-sys" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "winapi 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] name = "util" version = "0.0.1" dependencies = [ @@ -947,6 +1025,14 @@ dependencies = [ ] [[package]] +name = "winapi" +version = "0.1.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "libc 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] name = "xlib" version = "0.1.0" source = "git+https://github.com/servo/rust-xlib#715e6f9bb3dfcd925996caedeb77aefb31c2bd65" diff --git a/ports/gonk/fake-ld.sh b/ports/gonk/fake-ld.sh index ab18f01ec73..a03caea6322 100755 --- a/ports/gonk/fake-ld.sh +++ b/ports/gonk/fake-ld.sh @@ -1,2 +1,2 @@ #!/bin/bash -arm-linux-androideabi-g++ $@ $LDFLAGS -pie -lGLESv2 -lsupc++ -L$GONKDIR/prebuilts/ndk/9/sources/cxx-stl/gnu-libstdc++/4.6/libs/armeabi/ +arm-linux-androideabi-g++ $@ $LDFLAGS -pie -lGLESv2 -lsupc++ -L$GONKDIR/prebuilts/ndk/9/sources/cxx-stl/gnu-libstdc++/4.6/libs/armeabi/ -L$GONKDIR/backup-flame/system/lib/ diff --git a/support/android-rs-glue b/support/android-rs-glue -Subproject 34f588aace4d05ce42f4ca605d5470df8fdd236 +Subproject 5a68056599fb498b0cf3715fd359894825e3b85 diff --git a/tests/ref/basic.list b/tests/ref/basic.list index 6eaf667316b..2f17b1e9e59 100644 --- a/tests/ref/basic.list +++ b/tests/ref/basic.list @@ -329,6 +329,9 @@ resolution=600x800 == viewport_percentage_vmin_vmax.html viewport_percentage_vmi resolution=800x600 == viewport_percentage_vw_vh.html viewport_percentage_vw_vh_a.html resolution=600x800 == viewport_percentage_vw_vh.html viewport_percentage_vw_vh_b.html == visibility_hidden.html visibility_hidden_ref.html + +flaky_cpu == webgl-context/clearcolor.html webgl-context/clearcolor_ref.html + == whitespace_nowrap_a.html whitespace_nowrap_ref.html == whitespace_pre.html whitespace_pre_ref.html == width_nonreplaced_block_simple_a.html width_nonreplaced_block_simple_b.html diff --git a/tests/ref/webgl-context/clearcolor.html b/tests/ref/webgl-context/clearcolor.html new file mode 100644 index 00000000000..7d0bdeb8f2d --- /dev/null +++ b/tests/ref/webgl-context/clearcolor.html @@ -0,0 +1,25 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8" /> + <title>WebGL ClearColor Test</title> +</head> +<style> + +html, body { + margin: 0; +} + +</style> +<body> +<canvas id="canvas" width="640" height="480"></canvas> +<script type="text/javascript"> + +var gl = document.getElementById("canvas").getContext("webgl"); + +gl.clearColor(1.0, 0.0, 0.0, 1.0); +gl.clear(gl.COLOR_BUFFER_BIT); + +</script> +</body> +</html> diff --git a/tests/ref/webgl-context/clearcolor_ref.html b/tests/ref/webgl-context/clearcolor_ref.html new file mode 100644 index 00000000000..49cce2cc900 --- /dev/null +++ b/tests/ref/webgl-context/clearcolor_ref.html @@ -0,0 +1,20 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <title>WebGL ClearColor Test</title> +</head> +<style> + html, body { + margin: 0; + } + #canvas { + width: 640px; + height: 480px; + background-color: red; + } +</style> +<body> +<div id="canvas"></canvas> +</body> +</html> diff --git a/tests/wpt/mozilla/tests/mozilla/interfaces.html b/tests/wpt/mozilla/tests/mozilla/interfaces.html index a3a4712ee13..9649a9f3e15 100644 --- a/tests/wpt/mozilla/tests/mozilla/interfaces.html +++ b/tests/wpt/mozilla/tests/mozilla/interfaces.html @@ -175,6 +175,7 @@ var interfaceNamesInGlobalScope = [ "UIEvent", "URLSearchParams", "ValidityState", + "WebGLRenderingContext", "WebSocket", "Window", "Worker", |