diff options
| author | bors-servo <metajack+bors@gmail.com> | 2015-04-20 19:29:02 -0500 |
|---|---|---|
| committer | bors-servo <metajack+bors@gmail.com> | 2015-04-20 19:29:02 -0500 |
| commit | e4b620ea54c94e03095e4108bce94ec750416bba (patch) | |
| tree | 0af4f8dcc0b8d4e73c431ae66c5d90d62cecbfca /components | |
| parent | 99c6fbc3a439eb9fb43a2b0c2baeb14e54e50800 (diff) | |
| parent | c82485874d1fe1db89a2dac61c6d612a75b8e1a1 (diff) | |
| download | servo-e4b620ea54c94e03095e4108bce94ec750416bba.tar.gz servo-e4b620ea54c94e03095e4108bce94ec750416bba.zip | |
Auto merge of #5652 - dmarcos:webgl, r=jdm
@jdm @ecoal95 I'm working on making VR happen in the Browser and I want to bring to Servo the [webVR APIs](https://github.com/MozVR/webvr-spec/blob/master/webvr.idl) we already have in Gecko. Before anything happens we need a working implementation of WebGL (and also the [fullscreen API](https://fullscreen.spec.whatwg.org/)). My implementation is very basic and probably naive (I just recently started to contribute to Servo). My patch is just a starting point:
- It only implements ```clearColor``` and ```clear``` methods of the [WebGL spec](https://www.khronos.org/registry/webgl/specs/latest/).
- It uses the readback strategy that ```canvasRenderingContext2D``` is using (The webgl task paints stuff independently on it's own buffer and the compositor task request the pixels back to the webgl task when it needs them) I'm sure there are much better ways to handle this. Latency and FPS are critical in VR so we have to figure out the fastest way to push pixels to the screen. I've read something about layerizing the canvas but I'm still not sure what that even means :)
- There's an included test you can try ```./mach run tests/ref/webgl-context/clearcolor.html```
@ecoal95 I know you'll be working on this for the next three months. With a foundation in place we will be able to make quick progress in parallel. This is exciting!
<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/5652)
<!-- Reviewable:end -->
Diffstat (limited to 'components')
| -rw-r--r-- | components/canvas/Cargo.toml | 11 | ||||
| -rw-r--r-- | components/canvas/canvas_msg.rs | 61 | ||||
| -rw-r--r-- | components/canvas/canvas_paint_task.rs | 131 | ||||
| -rw-r--r-- | components/canvas/lib.rs | 6 | ||||
| -rw-r--r-- | components/canvas/webgl_paint_task.rs | 112 | ||||
| -rw-r--r-- | components/layout/display_list_builder.rs | 4 | ||||
| -rw-r--r-- | components/layout/fragment.rs | 2 | ||||
| -rw-r--r-- | components/layout/wrapper.rs | 2 | ||||
| -rw-r--r-- | components/script/dom/canvasrenderingcontext2d.rs | 83 | ||||
| -rw-r--r-- | components/script/dom/htmlcanvaselement.rs | 106 | ||||
| -rw-r--r-- | components/script/dom/mod.rs | 1 | ||||
| -rw-r--r-- | components/script/dom/webglrenderingcontext.rs | 75 | ||||
| -rw-r--r-- | components/script/dom/webidls/HTMLCanvasElement.webidl | 7 | ||||
| -rw-r--r-- | components/script/dom/webidls/WebGLRenderingContext.webidl | 739 | ||||
| -rw-r--r-- | components/servo/Cargo.lock | 5 |
15 files changed, 1184 insertions, 161 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)", |