mirror of
https://github.com/servo/servo.git
synced 2025-08-06 22:15:33 +01:00
Revert "Auto merge of #17891 - MortimerGoro:webgl_move, r=glennw,emilio"
This reverts commit90f55ea458, reversing changes made to2e60b27a21.
This commit is contained in:
Emilio Cobos Álvarez
parent
ee94e2b7c0
commit
cfe22e3979
54 changed files with 1426 additions and 3154 deletions
|
|
@ -15,8 +15,5 @@ euclid = "0.15"
|
|||
heapsize = "0.4"
|
||||
heapsize_derive = "0.1"
|
||||
ipc-channel = "0.8"
|
||||
lazy_static = "0.2"
|
||||
offscreen_gl_context = { version = "0.11", features = ["serde"] }
|
||||
serde = "1.0"
|
||||
servo_config = {path = "../config"}
|
||||
webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
|
||||
|
|
|
|||
|
|
@ -1,409 +0,0 @@
|
|||
/* 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 cssparser::RGBA;
|
||||
use euclid::{Transform2D, Point2D, Vector2D, Rect, Size2D};
|
||||
use ipc_channel::ipc::IpcSender;
|
||||
use std::default::Default;
|
||||
use std::str::FromStr;
|
||||
use webrender_api;
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum FillRule {
|
||||
Nonzero,
|
||||
Evenodd,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum CanvasMsg {
|
||||
Canvas2d(Canvas2dMsg),
|
||||
FromLayout(FromLayoutMsg),
|
||||
FromScript(FromScriptMsg),
|
||||
Recreate(Size2D<i32>),
|
||||
Close,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct CanvasImageData {
|
||||
pub image_key: webrender_api::ImageKey,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
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),
|
||||
DrawImageInOther(
|
||||
IpcSender<CanvasMsg>, Size2D<f64>, Rect<f64>, Rect<f64>, bool, IpcSender<()>),
|
||||
BeginPath,
|
||||
BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>),
|
||||
ClearRect(Rect<f32>),
|
||||
Clip,
|
||||
ClosePath,
|
||||
Fill,
|
||||
FillRect(Rect<f32>),
|
||||
GetImageData(Rect<i32>, Size2D<f64>, IpcSender<Vec<u8>>),
|
||||
IsPointInPath(f64, f64, FillRule, IpcSender<bool>),
|
||||
LineTo(Point2D<f32>),
|
||||
MoveTo(Point2D<f32>),
|
||||
PutImageData(Vec<u8>, Vector2D<f64>, Size2D<f64>, Rect<f64>),
|
||||
QuadraticCurveTo(Point2D<f32>, Point2D<f32>),
|
||||
Rect(Rect<f32>),
|
||||
RestoreContext,
|
||||
SaveContext,
|
||||
StrokeRect(Rect<f32>),
|
||||
Stroke,
|
||||
SetFillStyle(FillOrStrokeStyle),
|
||||
SetStrokeStyle(FillOrStrokeStyle),
|
||||
SetLineWidth(f32),
|
||||
SetLineCap(LineCapStyle),
|
||||
SetLineJoin(LineJoinStyle),
|
||||
SetMiterLimit(f32),
|
||||
SetGlobalAlpha(f32),
|
||||
SetGlobalComposition(CompositionOrBlending),
|
||||
SetTransform(Transform2D<f32>),
|
||||
SetShadowOffsetX(f64),
|
||||
SetShadowOffsetY(f64),
|
||||
SetShadowBlur(f64),
|
||||
SetShadowColor(RGBA),
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum FromLayoutMsg {
|
||||
SendData(IpcSender<CanvasImageData>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum FromScriptMsg {
|
||||
SendPixels(IpcSender<Option<Vec<u8>>>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub struct CanvasGradientStop {
|
||||
pub offset: f64,
|
||||
pub color: RGBA,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub struct LinearGradientStyle {
|
||||
pub x0: f64,
|
||||
pub y0: f64,
|
||||
pub x1: f64,
|
||||
pub y1: f64,
|
||||
pub stops: Vec<CanvasGradientStop>
|
||||
}
|
||||
|
||||
impl LinearGradientStyle {
|
||||
pub fn new(x0: f64, y0: f64, x1: f64, y1: f64, stops: Vec<CanvasGradientStop>)
|
||||
-> LinearGradientStyle {
|
||||
LinearGradientStyle {
|
||||
x0: x0,
|
||||
y0: y0,
|
||||
x1: x1,
|
||||
y1: y1,
|
||||
stops: stops,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub struct RadialGradientStyle {
|
||||
pub x0: f64,
|
||||
pub y0: f64,
|
||||
pub r0: f64,
|
||||
pub x1: f64,
|
||||
pub y1: f64,
|
||||
pub r1: f64,
|
||||
pub stops: Vec<CanvasGradientStop>
|
||||
}
|
||||
|
||||
impl RadialGradientStyle {
|
||||
pub fn new(x0: f64, y0: f64, r0: f64, x1: f64, y1: f64, r1: f64, stops: Vec<CanvasGradientStop>)
|
||||
-> RadialGradientStyle {
|
||||
RadialGradientStyle {
|
||||
x0: x0,
|
||||
y0: y0,
|
||||
r0: r0,
|
||||
x1: x1,
|
||||
y1: y1,
|
||||
r1: r1,
|
||||
stops: stops,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct SurfaceStyle {
|
||||
pub surface_data: Vec<u8>,
|
||||
pub surface_size: Size2D<i32>,
|
||||
pub repeat_x: bool,
|
||||
pub repeat_y: bool,
|
||||
}
|
||||
|
||||
impl SurfaceStyle {
|
||||
pub fn new(surface_data: Vec<u8>, surface_size: Size2D<i32>, repeat_x: bool, repeat_y: bool)
|
||||
-> SurfaceStyle {
|
||||
SurfaceStyle {
|
||||
surface_data: surface_data,
|
||||
surface_size: surface_size,
|
||||
repeat_x: repeat_x,
|
||||
repeat_y: repeat_y,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum FillOrStrokeStyle {
|
||||
Color(RGBA),
|
||||
LinearGradient(LinearGradientStyle),
|
||||
RadialGradient(RadialGradientStyle),
|
||||
Surface(SurfaceStyle),
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum LineCapStyle {
|
||||
Butt = 0,
|
||||
Round = 1,
|
||||
Square = 2,
|
||||
}
|
||||
|
||||
impl FromStr for LineCapStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<LineCapStyle, ()> {
|
||||
match string {
|
||||
"butt" => Ok(LineCapStyle::Butt),
|
||||
"round" => Ok(LineCapStyle::Round),
|
||||
"square" => Ok(LineCapStyle::Square),
|
||||
_ => Err(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum LineJoinStyle {
|
||||
Round = 0,
|
||||
Bevel = 1,
|
||||
Miter = 2,
|
||||
}
|
||||
|
||||
impl FromStr for LineJoinStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<LineJoinStyle, ()> {
|
||||
match string {
|
||||
"round" => Ok(LineJoinStyle::Round),
|
||||
"bevel" => Ok(LineJoinStyle::Bevel),
|
||||
"miter" => Ok(LineJoinStyle::Miter),
|
||||
_ => Err(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize)]
|
||||
pub enum RepetitionStyle {
|
||||
Repeat,
|
||||
RepeatX,
|
||||
RepeatY,
|
||||
NoRepeat,
|
||||
}
|
||||
|
||||
impl FromStr for RepetitionStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<RepetitionStyle, ()> {
|
||||
match string {
|
||||
"repeat" => Ok(RepetitionStyle::Repeat),
|
||||
"repeat-x" => Ok(RepetitionStyle::RepeatX),
|
||||
"repeat-y" => Ok(RepetitionStyle::RepeatY),
|
||||
"no-repeat" => Ok(RepetitionStyle::NoRepeat),
|
||||
_ => Err(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum CompositionStyle {
|
||||
SrcIn,
|
||||
SrcOut,
|
||||
SrcOver,
|
||||
SrcAtop,
|
||||
DestIn,
|
||||
DestOut,
|
||||
DestOver,
|
||||
DestAtop,
|
||||
Copy,
|
||||
Lighter,
|
||||
Xor,
|
||||
}
|
||||
|
||||
impl FromStr for CompositionStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<CompositionStyle, ()> {
|
||||
match string {
|
||||
"source-in" => Ok(CompositionStyle::SrcIn),
|
||||
"source-out" => Ok(CompositionStyle::SrcOut),
|
||||
"source-over" => Ok(CompositionStyle::SrcOver),
|
||||
"source-atop" => Ok(CompositionStyle::SrcAtop),
|
||||
"destination-in" => Ok(CompositionStyle::DestIn),
|
||||
"destination-out" => Ok(CompositionStyle::DestOut),
|
||||
"destination-over" => Ok(CompositionStyle::DestOver),
|
||||
"destination-atop" => Ok(CompositionStyle::DestAtop),
|
||||
"copy" => Ok(CompositionStyle::Copy),
|
||||
"lighter" => Ok(CompositionStyle::Lighter),
|
||||
"xor" => Ok(CompositionStyle::Xor),
|
||||
_ => Err(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl CompositionStyle {
|
||||
pub fn to_str(&self) -> &str {
|
||||
match *self {
|
||||
CompositionStyle::SrcIn => "source-in",
|
||||
CompositionStyle::SrcOut => "source-out",
|
||||
CompositionStyle::SrcOver => "source-over",
|
||||
CompositionStyle::SrcAtop => "source-atop",
|
||||
CompositionStyle::DestIn => "destination-in",
|
||||
CompositionStyle::DestOut => "destination-out",
|
||||
CompositionStyle::DestOver => "destination-over",
|
||||
CompositionStyle::DestAtop => "destination-atop",
|
||||
CompositionStyle::Copy => "copy",
|
||||
CompositionStyle::Lighter => "lighter",
|
||||
CompositionStyle::Xor => "xor",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum BlendingStyle {
|
||||
Multiply,
|
||||
Screen,
|
||||
Overlay,
|
||||
Darken,
|
||||
Lighten,
|
||||
ColorDodge,
|
||||
ColorBurn,
|
||||
HardLight,
|
||||
SoftLight,
|
||||
Difference,
|
||||
Exclusion,
|
||||
Hue,
|
||||
Saturation,
|
||||
Color,
|
||||
Luminosity,
|
||||
}
|
||||
|
||||
impl FromStr for BlendingStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<BlendingStyle, ()> {
|
||||
match string {
|
||||
"multiply" => Ok(BlendingStyle::Multiply),
|
||||
"screen" => Ok(BlendingStyle::Screen),
|
||||
"overlay" => Ok(BlendingStyle::Overlay),
|
||||
"darken" => Ok(BlendingStyle::Darken),
|
||||
"lighten" => Ok(BlendingStyle::Lighten),
|
||||
"color-dodge" => Ok(BlendingStyle::ColorDodge),
|
||||
"color-burn" => Ok(BlendingStyle::ColorBurn),
|
||||
"hard-light" => Ok(BlendingStyle::HardLight),
|
||||
"soft-light" => Ok(BlendingStyle::SoftLight),
|
||||
"difference" => Ok(BlendingStyle::Difference),
|
||||
"exclusion" => Ok(BlendingStyle::Exclusion),
|
||||
"hue" => Ok(BlendingStyle::Hue),
|
||||
"saturation" => Ok(BlendingStyle::Saturation),
|
||||
"color" => Ok(BlendingStyle::Color),
|
||||
"luminosity" => Ok(BlendingStyle::Luminosity),
|
||||
_ => Err(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl BlendingStyle {
|
||||
pub fn to_str(&self) -> &str {
|
||||
match *self {
|
||||
BlendingStyle::Multiply => "multiply",
|
||||
BlendingStyle::Screen => "screen",
|
||||
BlendingStyle::Overlay => "overlay",
|
||||
BlendingStyle::Darken => "darken",
|
||||
BlendingStyle::Lighten => "lighten",
|
||||
BlendingStyle::ColorDodge => "color-dodge",
|
||||
BlendingStyle::ColorBurn => "color-burn",
|
||||
BlendingStyle::HardLight => "hard-light",
|
||||
BlendingStyle::SoftLight => "soft-light",
|
||||
BlendingStyle::Difference => "difference",
|
||||
BlendingStyle::Exclusion => "exclusion",
|
||||
BlendingStyle::Hue => "hue",
|
||||
BlendingStyle::Saturation => "saturation",
|
||||
BlendingStyle::Color => "color",
|
||||
BlendingStyle::Luminosity => "luminosity",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum CompositionOrBlending {
|
||||
Composition(CompositionStyle),
|
||||
Blending(BlendingStyle),
|
||||
}
|
||||
|
||||
impl Default for CompositionOrBlending {
|
||||
fn default() -> CompositionOrBlending {
|
||||
CompositionOrBlending::Composition(CompositionStyle::SrcOver)
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for CompositionOrBlending {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<CompositionOrBlending, ()> {
|
||||
if let Ok(op) = CompositionStyle::from_str(string) {
|
||||
return Ok(CompositionOrBlending::Composition(op));
|
||||
}
|
||||
|
||||
if let Ok(op) = BlendingStyle::from_str(string) {
|
||||
return Ok(CompositionOrBlending::Blending(op));
|
||||
}
|
||||
|
||||
Err(())
|
||||
}
|
||||
}
|
||||
|
||||
// TODO(pcwalton): Speed up with SIMD, or better yet, find some way to not do this.
|
||||
pub fn byte_swap(data: &mut [u8]) {
|
||||
let length = data.len();
|
||||
// FIXME(rust #27741): Range::step_by is not stable yet as of this writing.
|
||||
let mut i = 0;
|
||||
while i < length {
|
||||
let r = data[i + 2];
|
||||
data[i + 2] = data[i + 0];
|
||||
data[i + 0] = r;
|
||||
i += 4;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn multiply_u8_pixel(a: u8, b: u8) -> u8 {
|
||||
return (a as u32 * b as u32 / 255) as u8;
|
||||
}
|
||||
|
||||
pub fn byte_swap_and_premultiply(data: &mut [u8]) {
|
||||
let length = data.len();
|
||||
|
||||
let mut i = 0;
|
||||
while i < length {
|
||||
let r = data[i + 2];
|
||||
let g = data[i + 1];
|
||||
let b = data[i + 0];
|
||||
let a = data[i + 3];
|
||||
|
||||
data[i + 0] = multiply_u8_pixel(r, a);
|
||||
data[i + 1] = multiply_u8_pixel(g, a);
|
||||
data[i + 2] = multiply_u8_pixel(b, a);
|
||||
|
||||
i += 4;
|
||||
}
|
||||
}
|
||||
|
|
@ -4,22 +4,432 @@
|
|||
|
||||
#![crate_name = "canvas_traits"]
|
||||
#![crate_type = "rlib"]
|
||||
#![feature(nonzero)]
|
||||
|
||||
#![deny(unsafe_code)]
|
||||
|
||||
extern crate core;
|
||||
extern crate cssparser;
|
||||
extern crate euclid;
|
||||
extern crate heapsize;
|
||||
#[macro_use] extern crate heapsize_derive;
|
||||
extern crate ipc_channel;
|
||||
#[macro_use] extern crate lazy_static;
|
||||
extern crate offscreen_gl_context;
|
||||
#[macro_use] extern crate serde;
|
||||
extern crate servo_config;
|
||||
extern crate webrender_api;
|
||||
|
||||
pub mod canvas;
|
||||
pub mod webgl;
|
||||
mod webgl_channel;
|
||||
use cssparser::RGBA;
|
||||
use euclid::{Transform2D, Point2D, Vector2D, Rect, Size2D};
|
||||
use ipc_channel::ipc::IpcSender;
|
||||
use std::default::Default;
|
||||
use std::str::FromStr;
|
||||
use webrender_api::{WebGLCommand, WebGLContextId, VRCompositorCommand};
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum FillRule {
|
||||
Nonzero,
|
||||
Evenodd,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum CanvasMsg {
|
||||
Canvas2d(Canvas2dMsg),
|
||||
Common(CanvasCommonMsg),
|
||||
FromLayout(FromLayoutMsg),
|
||||
FromScript(FromScriptMsg),
|
||||
WebGL(WebGLCommand),
|
||||
WebVR(VRCompositorCommand)
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum CanvasCommonMsg {
|
||||
Close,
|
||||
Recreate(Size2D<i32>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum CanvasData {
|
||||
Image(CanvasImageData),
|
||||
WebGL(WebGLContextId),
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct CanvasImageData {
|
||||
pub image_key: webrender_api::ImageKey,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum FromLayoutMsg {
|
||||
SendData(IpcSender<CanvasData>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum FromScriptMsg {
|
||||
SendPixels(IpcSender<Option<Vec<u8>>>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
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),
|
||||
DrawImageInOther(
|
||||
IpcSender<CanvasMsg>, Size2D<f64>, Rect<f64>, Rect<f64>, bool, IpcSender<()>),
|
||||
BeginPath,
|
||||
BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>),
|
||||
ClearRect(Rect<f32>),
|
||||
Clip,
|
||||
ClosePath,
|
||||
Fill,
|
||||
FillRect(Rect<f32>),
|
||||
GetImageData(Rect<i32>, Size2D<f64>, IpcSender<Vec<u8>>),
|
||||
IsPointInPath(f64, f64, FillRule, IpcSender<bool>),
|
||||
LineTo(Point2D<f32>),
|
||||
MoveTo(Point2D<f32>),
|
||||
PutImageData(Vec<u8>, Vector2D<f64>, Size2D<f64>, Rect<f64>),
|
||||
QuadraticCurveTo(Point2D<f32>, Point2D<f32>),
|
||||
Rect(Rect<f32>),
|
||||
RestoreContext,
|
||||
SaveContext,
|
||||
StrokeRect(Rect<f32>),
|
||||
Stroke,
|
||||
SetFillStyle(FillOrStrokeStyle),
|
||||
SetStrokeStyle(FillOrStrokeStyle),
|
||||
SetLineWidth(f32),
|
||||
SetLineCap(LineCapStyle),
|
||||
SetLineJoin(LineJoinStyle),
|
||||
SetMiterLimit(f32),
|
||||
SetGlobalAlpha(f32),
|
||||
SetGlobalComposition(CompositionOrBlending),
|
||||
SetTransform(Transform2D<f32>),
|
||||
SetShadowOffsetX(f64),
|
||||
SetShadowOffsetY(f64),
|
||||
SetShadowBlur(f64),
|
||||
SetShadowColor(RGBA),
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub struct CanvasGradientStop {
|
||||
pub offset: f64,
|
||||
pub color: RGBA,
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub struct LinearGradientStyle {
|
||||
pub x0: f64,
|
||||
pub y0: f64,
|
||||
pub x1: f64,
|
||||
pub y1: f64,
|
||||
pub stops: Vec<CanvasGradientStop>
|
||||
}
|
||||
|
||||
impl LinearGradientStyle {
|
||||
pub fn new(x0: f64, y0: f64, x1: f64, y1: f64, stops: Vec<CanvasGradientStop>)
|
||||
-> LinearGradientStyle {
|
||||
LinearGradientStyle {
|
||||
x0: x0,
|
||||
y0: y0,
|
||||
x1: x1,
|
||||
y1: y1,
|
||||
stops: stops,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub struct RadialGradientStyle {
|
||||
pub x0: f64,
|
||||
pub y0: f64,
|
||||
pub r0: f64,
|
||||
pub x1: f64,
|
||||
pub y1: f64,
|
||||
pub r1: f64,
|
||||
pub stops: Vec<CanvasGradientStop>
|
||||
}
|
||||
|
||||
impl RadialGradientStyle {
|
||||
pub fn new(x0: f64, y0: f64, r0: f64, x1: f64, y1: f64, r1: f64, stops: Vec<CanvasGradientStop>)
|
||||
-> RadialGradientStyle {
|
||||
RadialGradientStyle {
|
||||
x0: x0,
|
||||
y0: y0,
|
||||
r0: r0,
|
||||
x1: x1,
|
||||
y1: y1,
|
||||
r1: r1,
|
||||
stops: stops,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct SurfaceStyle {
|
||||
pub surface_data: Vec<u8>,
|
||||
pub surface_size: Size2D<i32>,
|
||||
pub repeat_x: bool,
|
||||
pub repeat_y: bool,
|
||||
}
|
||||
|
||||
impl SurfaceStyle {
|
||||
pub fn new(surface_data: Vec<u8>, surface_size: Size2D<i32>, repeat_x: bool, repeat_y: bool)
|
||||
-> SurfaceStyle {
|
||||
SurfaceStyle {
|
||||
surface_data: surface_data,
|
||||
surface_size: surface_size,
|
||||
repeat_x: repeat_x,
|
||||
repeat_y: repeat_y,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum FillOrStrokeStyle {
|
||||
Color(RGBA),
|
||||
LinearGradient(LinearGradientStyle),
|
||||
RadialGradient(RadialGradientStyle),
|
||||
Surface(SurfaceStyle),
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum LineCapStyle {
|
||||
Butt = 0,
|
||||
Round = 1,
|
||||
Square = 2,
|
||||
}
|
||||
|
||||
impl FromStr for LineCapStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<LineCapStyle, ()> {
|
||||
match string {
|
||||
"butt" => Ok(LineCapStyle::Butt),
|
||||
"round" => Ok(LineCapStyle::Round),
|
||||
"square" => Ok(LineCapStyle::Square),
|
||||
_ => Err(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum LineJoinStyle {
|
||||
Round = 0,
|
||||
Bevel = 1,
|
||||
Miter = 2,
|
||||
}
|
||||
|
||||
impl FromStr for LineJoinStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<LineJoinStyle, ()> {
|
||||
match string {
|
||||
"round" => Ok(LineJoinStyle::Round),
|
||||
"bevel" => Ok(LineJoinStyle::Bevel),
|
||||
"miter" => Ok(LineJoinStyle::Miter),
|
||||
_ => Err(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize)]
|
||||
pub enum RepetitionStyle {
|
||||
Repeat,
|
||||
RepeatX,
|
||||
RepeatY,
|
||||
NoRepeat,
|
||||
}
|
||||
|
||||
impl FromStr for RepetitionStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<RepetitionStyle, ()> {
|
||||
match string {
|
||||
"repeat" => Ok(RepetitionStyle::Repeat),
|
||||
"repeat-x" => Ok(RepetitionStyle::RepeatX),
|
||||
"repeat-y" => Ok(RepetitionStyle::RepeatY),
|
||||
"no-repeat" => Ok(RepetitionStyle::NoRepeat),
|
||||
_ => Err(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum CompositionStyle {
|
||||
SrcIn,
|
||||
SrcOut,
|
||||
SrcOver,
|
||||
SrcAtop,
|
||||
DestIn,
|
||||
DestOut,
|
||||
DestOver,
|
||||
DestAtop,
|
||||
Copy,
|
||||
Lighter,
|
||||
Xor,
|
||||
}
|
||||
|
||||
impl FromStr for CompositionStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<CompositionStyle, ()> {
|
||||
match string {
|
||||
"source-in" => Ok(CompositionStyle::SrcIn),
|
||||
"source-out" => Ok(CompositionStyle::SrcOut),
|
||||
"source-over" => Ok(CompositionStyle::SrcOver),
|
||||
"source-atop" => Ok(CompositionStyle::SrcAtop),
|
||||
"destination-in" => Ok(CompositionStyle::DestIn),
|
||||
"destination-out" => Ok(CompositionStyle::DestOut),
|
||||
"destination-over" => Ok(CompositionStyle::DestOver),
|
||||
"destination-atop" => Ok(CompositionStyle::DestAtop),
|
||||
"copy" => Ok(CompositionStyle::Copy),
|
||||
"lighter" => Ok(CompositionStyle::Lighter),
|
||||
"xor" => Ok(CompositionStyle::Xor),
|
||||
_ => Err(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl CompositionStyle {
|
||||
pub fn to_str(&self) -> &str {
|
||||
match *self {
|
||||
CompositionStyle::SrcIn => "source-in",
|
||||
CompositionStyle::SrcOut => "source-out",
|
||||
CompositionStyle::SrcOver => "source-over",
|
||||
CompositionStyle::SrcAtop => "source-atop",
|
||||
CompositionStyle::DestIn => "destination-in",
|
||||
CompositionStyle::DestOut => "destination-out",
|
||||
CompositionStyle::DestOver => "destination-over",
|
||||
CompositionStyle::DestAtop => "destination-atop",
|
||||
CompositionStyle::Copy => "copy",
|
||||
CompositionStyle::Lighter => "lighter",
|
||||
CompositionStyle::Xor => "xor",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum BlendingStyle {
|
||||
Multiply,
|
||||
Screen,
|
||||
Overlay,
|
||||
Darken,
|
||||
Lighten,
|
||||
ColorDodge,
|
||||
ColorBurn,
|
||||
HardLight,
|
||||
SoftLight,
|
||||
Difference,
|
||||
Exclusion,
|
||||
Hue,
|
||||
Saturation,
|
||||
Color,
|
||||
Luminosity,
|
||||
}
|
||||
|
||||
impl FromStr for BlendingStyle {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<BlendingStyle, ()> {
|
||||
match string {
|
||||
"multiply" => Ok(BlendingStyle::Multiply),
|
||||
"screen" => Ok(BlendingStyle::Screen),
|
||||
"overlay" => Ok(BlendingStyle::Overlay),
|
||||
"darken" => Ok(BlendingStyle::Darken),
|
||||
"lighten" => Ok(BlendingStyle::Lighten),
|
||||
"color-dodge" => Ok(BlendingStyle::ColorDodge),
|
||||
"color-burn" => Ok(BlendingStyle::ColorBurn),
|
||||
"hard-light" => Ok(BlendingStyle::HardLight),
|
||||
"soft-light" => Ok(BlendingStyle::SoftLight),
|
||||
"difference" => Ok(BlendingStyle::Difference),
|
||||
"exclusion" => Ok(BlendingStyle::Exclusion),
|
||||
"hue" => Ok(BlendingStyle::Hue),
|
||||
"saturation" => Ok(BlendingStyle::Saturation),
|
||||
"color" => Ok(BlendingStyle::Color),
|
||||
"luminosity" => Ok(BlendingStyle::Luminosity),
|
||||
_ => Err(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl BlendingStyle {
|
||||
pub fn to_str(&self) -> &str {
|
||||
match *self {
|
||||
BlendingStyle::Multiply => "multiply",
|
||||
BlendingStyle::Screen => "screen",
|
||||
BlendingStyle::Overlay => "overlay",
|
||||
BlendingStyle::Darken => "darken",
|
||||
BlendingStyle::Lighten => "lighten",
|
||||
BlendingStyle::ColorDodge => "color-dodge",
|
||||
BlendingStyle::ColorBurn => "color-burn",
|
||||
BlendingStyle::HardLight => "hard-light",
|
||||
BlendingStyle::SoftLight => "soft-light",
|
||||
BlendingStyle::Difference => "difference",
|
||||
BlendingStyle::Exclusion => "exclusion",
|
||||
BlendingStyle::Hue => "hue",
|
||||
BlendingStyle::Saturation => "saturation",
|
||||
BlendingStyle::Color => "color",
|
||||
BlendingStyle::Luminosity => "luminosity",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Deserialize, Serialize, HeapSizeOf)]
|
||||
pub enum CompositionOrBlending {
|
||||
Composition(CompositionStyle),
|
||||
Blending(BlendingStyle),
|
||||
}
|
||||
|
||||
impl Default for CompositionOrBlending {
|
||||
fn default() -> CompositionOrBlending {
|
||||
CompositionOrBlending::Composition(CompositionStyle::SrcOver)
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for CompositionOrBlending {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(string: &str) -> Result<CompositionOrBlending, ()> {
|
||||
if let Ok(op) = CompositionStyle::from_str(string) {
|
||||
return Ok(CompositionOrBlending::Composition(op));
|
||||
}
|
||||
|
||||
if let Ok(op) = BlendingStyle::from_str(string) {
|
||||
return Ok(CompositionOrBlending::Blending(op));
|
||||
}
|
||||
|
||||
Err(())
|
||||
}
|
||||
}
|
||||
|
||||
// TODO(pcwalton): Speed up with SIMD, or better yet, find some way to not do this.
|
||||
pub fn byte_swap(data: &mut [u8]) {
|
||||
let length = data.len();
|
||||
// FIXME(rust #27741): Range::step_by is not stable yet as of this writing.
|
||||
let mut i = 0;
|
||||
while i < length {
|
||||
let r = data[i + 2];
|
||||
data[i + 2] = data[i + 0];
|
||||
data[i + 0] = r;
|
||||
i += 4;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn multiply_u8_pixel(a: u8, b: u8) -> u8 {
|
||||
return (a as u32 * b as u32 / 255) as u8;
|
||||
}
|
||||
|
||||
pub fn byte_swap_and_premultiply(data: &mut [u8]) {
|
||||
let length = data.len();
|
||||
|
||||
let mut i = 0;
|
||||
while i < length {
|
||||
let r = data[i + 2];
|
||||
let g = data[i + 1];
|
||||
let b = data[i + 0];
|
||||
let a = data[i + 3];
|
||||
|
||||
data[i + 0] = multiply_u8_pixel(r, a);
|
||||
data[i + 1] = multiply_u8_pixel(g, a);
|
||||
data[i + 2] = multiply_u8_pixel(b, a);
|
||||
|
||||
i += 4;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,506 +0,0 @@
|
|||
/* 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 core::nonzero::NonZero;
|
||||
use euclid::Size2D;
|
||||
use offscreen_gl_context::{GLContextAttributes, GLLimits};
|
||||
use std::fmt;
|
||||
use webrender_api;
|
||||
|
||||
/// Sender type used in WebGLCommands.
|
||||
pub use ::webgl_channel::WebGLSender;
|
||||
/// Receiver type used in WebGLCommands.
|
||||
pub use ::webgl_channel::WebGLReceiver;
|
||||
/// Result type for send()/recv() calls in in WebGLCommands.
|
||||
pub use ::webgl_channel::WebGLSendResult;
|
||||
/// Helper function that creates a WebGL channel (WebGLSender, WebGLReceiver) to be used in WebGLCommands.
|
||||
pub use ::webgl_channel::webgl_channel;
|
||||
/// Entry point type used in a Script Pipeline to get the WebGLChan to be used in that thread.
|
||||
pub use ::webgl_channel::WebGLPipeline;
|
||||
/// Entry point channel type used for sending WebGLMsg messages to the WebGL renderer.
|
||||
pub use ::webgl_channel::WebGLChan;
|
||||
|
||||
/// WebGL Message API
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum WebGLMsg {
|
||||
/// Creates a new WebGLContext.
|
||||
CreateContext(Size2D<i32>, GLContextAttributes, WebGLSender<Result<(WebGLCreateContextResult), String>>),
|
||||
/// Resizes a WebGLContext.
|
||||
ResizeContext(WebGLContextId, Size2D<i32>, WebGLSender<Result<(), String>>),
|
||||
/// Drops a WebGLContext.
|
||||
RemoveContext(WebGLContextId),
|
||||
/// Runs a WebGLCommand in a specific WebGLContext.
|
||||
WebGLCommand(WebGLContextId, WebGLCommand),
|
||||
/// Runs a WebVRCommand in a specific WebGLContext.
|
||||
WebVRCommand(WebGLContextId, WebVRCommand),
|
||||
/// Locks a specific WebGLContext. Lock messages are used for a correct synchronization
|
||||
/// with WebRender external image API.
|
||||
/// WR locks a external texture when it wants to use the shared texture contents.
|
||||
/// The WR client should not change the shared texture content until the Unlock call.
|
||||
/// Currently OpenGL Sync Objects are used to implement the synchronization mechanism.
|
||||
Lock(WebGLContextId, WebGLSender<(u32, Size2D<i32>)>),
|
||||
/// Unlocks a specific WebGLContext. Unlock messages are used for a correct synchronization
|
||||
/// with WebRender external image API.
|
||||
/// The WR unlocks a context when it finished reading the shared texture contents.
|
||||
/// Unlock messages are always sent after a Lock message.
|
||||
Unlock(WebGLContextId),
|
||||
/// Creates or updates the image keys required for WebRender.
|
||||
UpdateWebRenderImage(WebGLContextId, WebGLSender<webrender_api::ImageKey>),
|
||||
/// Frees all resources and closes the thread.
|
||||
Exit,
|
||||
}
|
||||
|
||||
/// Contains the WebGLCommand sender and information about a WebGLContext
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct WebGLCreateContextResult {
|
||||
/// Sender instance to send commands to the specific WebGLContext
|
||||
pub sender: WebGLMsgSender,
|
||||
/// Information about the internal GL Context.
|
||||
pub limits: GLLimits,
|
||||
/// How the WebGLContext is shared with WebRender.
|
||||
pub share_mode: WebGLContextShareMode,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Deserialize, HeapSizeOf, Serialize)]
|
||||
pub enum WebGLContextShareMode {
|
||||
/// Fast: a shared texture_id is used in WebRender.
|
||||
SharedTexture,
|
||||
/// Slow: glReadPixels is used to send pixels to WebRender each frame.
|
||||
Readback,
|
||||
}
|
||||
|
||||
/// Helper struct to send WebGLCommands to a specific WebGLContext.
|
||||
#[derive(Clone, Deserialize, HeapSizeOf, Serialize)]
|
||||
pub struct WebGLMsgSender {
|
||||
ctx_id: WebGLContextId,
|
||||
#[ignore_heap_size_of = "channels are hard"]
|
||||
sender: WebGLChan,
|
||||
}
|
||||
|
||||
impl WebGLMsgSender {
|
||||
pub fn new(id: WebGLContextId, sender: WebGLChan) -> Self {
|
||||
WebGLMsgSender {
|
||||
ctx_id: id,
|
||||
sender: sender,
|
||||
}
|
||||
}
|
||||
|
||||
/// Send a WebGLCommand message
|
||||
#[inline]
|
||||
pub fn send(&self, command: WebGLCommand) -> WebGLSendResult {
|
||||
self.sender.send(WebGLMsg::WebGLCommand(self.ctx_id, command))
|
||||
}
|
||||
|
||||
/// Send a WebVRCommand message
|
||||
#[inline]
|
||||
pub fn send_vr(&self, command: WebVRCommand) -> WebGLSendResult {
|
||||
self.sender.send(WebGLMsg::WebVRCommand(self.ctx_id, command))
|
||||
}
|
||||
|
||||
/// Send a resize message
|
||||
#[inline]
|
||||
pub fn send_resize(&self,
|
||||
size: Size2D<i32>,
|
||||
sender: WebGLSender<Result<(), String>>)
|
||||
-> WebGLSendResult {
|
||||
self.sender.send(WebGLMsg::ResizeContext(self.ctx_id, size, sender))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn send_remove(&self) -> WebGLSendResult {
|
||||
self.sender.send(WebGLMsg::RemoveContext(self.ctx_id))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn send_update_wr_image(&self, sender: WebGLSender<webrender_api::ImageKey>) -> WebGLSendResult {
|
||||
self.sender.send(WebGLMsg::UpdateWebRenderImage(self.ctx_id, sender))
|
||||
}
|
||||
}
|
||||
|
||||
/// WebGL Commands for a specific WebGLContext
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum WebGLCommand {
|
||||
GetContextAttributes(WebGLSender<GLContextAttributes>),
|
||||
ActiveTexture(u32),
|
||||
BlendColor(f32, f32, f32, f32),
|
||||
BlendEquation(u32),
|
||||
BlendEquationSeparate(u32, u32),
|
||||
BlendFunc(u32, u32),
|
||||
BlendFuncSeparate(u32, u32, u32, u32),
|
||||
AttachShader(WebGLProgramId, WebGLShaderId),
|
||||
DetachShader(WebGLProgramId, WebGLShaderId),
|
||||
BindAttribLocation(WebGLProgramId, u32, String),
|
||||
BufferData(u32, Vec<u8>, u32),
|
||||
BufferSubData(u32, isize, Vec<u8>),
|
||||
Clear(u32),
|
||||
ClearColor(f32, f32, f32, f32),
|
||||
ClearDepth(f64),
|
||||
ClearStencil(i32),
|
||||
ColorMask(bool, bool, bool, bool),
|
||||
CullFace(u32),
|
||||
FrontFace(u32),
|
||||
DepthFunc(u32),
|
||||
DepthMask(bool),
|
||||
DepthRange(f64, f64),
|
||||
Enable(u32),
|
||||
Disable(u32),
|
||||
CompileShader(WebGLShaderId, String),
|
||||
CopyTexImage2D(u32, i32, u32, i32, i32, i32, i32, i32),
|
||||
CopyTexSubImage2D(u32, i32, i32, i32, i32, i32, i32, i32),
|
||||
CreateBuffer(WebGLSender<Option<WebGLBufferId>>),
|
||||
CreateFramebuffer(WebGLSender<Option<WebGLFramebufferId>>),
|
||||
CreateRenderbuffer(WebGLSender<Option<WebGLRenderbufferId>>),
|
||||
CreateTexture(WebGLSender<Option<WebGLTextureId>>),
|
||||
CreateProgram(WebGLSender<Option<WebGLProgramId>>),
|
||||
CreateShader(u32, WebGLSender<Option<WebGLShaderId>>),
|
||||
DeleteBuffer(WebGLBufferId),
|
||||
DeleteFramebuffer(WebGLFramebufferId),
|
||||
DeleteRenderbuffer(WebGLRenderbufferId),
|
||||
DeleteTexture(WebGLTextureId),
|
||||
DeleteProgram(WebGLProgramId),
|
||||
DeleteShader(WebGLShaderId),
|
||||
BindBuffer(u32, Option<WebGLBufferId>),
|
||||
BindFramebuffer(u32, WebGLFramebufferBindingRequest),
|
||||
BindRenderbuffer(u32, Option<WebGLRenderbufferId>),
|
||||
BindTexture(u32, Option<WebGLTextureId>),
|
||||
DisableVertexAttribArray(u32),
|
||||
DrawArrays(u32, i32, i32),
|
||||
DrawElements(u32, i32, u32, i64),
|
||||
EnableVertexAttribArray(u32),
|
||||
FramebufferRenderbuffer(u32, u32, u32, Option<WebGLRenderbufferId>),
|
||||
FramebufferTexture2D(u32, u32, u32, Option<WebGLTextureId>, i32),
|
||||
GetBufferParameter(u32, u32, WebGLSender<WebGLResult<WebGLParameter>>),
|
||||
GetExtensions(WebGLSender<String>),
|
||||
GetParameter(u32, WebGLSender<WebGLResult<WebGLParameter>>),
|
||||
GetProgramParameter(WebGLProgramId, u32, WebGLSender<WebGLResult<WebGLParameter>>),
|
||||
GetShaderParameter(WebGLShaderId, u32, WebGLSender<WebGLResult<WebGLParameter>>),
|
||||
GetShaderPrecisionFormat(u32, u32, WebGLSender<WebGLResult<(i32, i32, i32)>>),
|
||||
GetActiveAttrib(WebGLProgramId, u32, WebGLSender<WebGLResult<(i32, u32, String)>>),
|
||||
GetActiveUniform(WebGLProgramId, u32, WebGLSender<WebGLResult<(i32, u32, String)>>),
|
||||
GetAttribLocation(WebGLProgramId, String, WebGLSender<Option<i32>>),
|
||||
GetUniformLocation(WebGLProgramId, String, WebGLSender<Option<i32>>),
|
||||
GetVertexAttrib(u32, u32, WebGLSender<WebGLResult<WebGLParameter>>),
|
||||
GetVertexAttribOffset(u32, u32, WebGLSender<WebGLResult<isize>>),
|
||||
GetShaderInfoLog(WebGLShaderId, WebGLSender<String>),
|
||||
GetProgramInfoLog(WebGLProgramId, WebGLSender<String>),
|
||||
PolygonOffset(f32, f32),
|
||||
RenderbufferStorage(u32, u32, i32, i32),
|
||||
ReadPixels(i32, i32, i32, i32, u32, u32, WebGLSender<Vec<u8>>),
|
||||
SampleCoverage(f32, bool),
|
||||
Scissor(i32, i32, i32, i32),
|
||||
StencilFunc(u32, i32, u32),
|
||||
StencilFuncSeparate(u32, u32, i32, u32),
|
||||
StencilMask(u32),
|
||||
StencilMaskSeparate(u32, u32),
|
||||
StencilOp(u32, u32, u32),
|
||||
StencilOpSeparate(u32, u32, u32, u32),
|
||||
Hint(u32, u32),
|
||||
IsEnabled(u32, WebGLSender<bool>),
|
||||
LineWidth(f32),
|
||||
PixelStorei(u32, i32),
|
||||
LinkProgram(WebGLProgramId),
|
||||
Uniform1f(i32, f32),
|
||||
Uniform1fv(i32, Vec<f32>),
|
||||
Uniform1i(i32, i32),
|
||||
Uniform1iv(i32, Vec<i32>),
|
||||
Uniform2f(i32, f32, f32),
|
||||
Uniform2fv(i32, Vec<f32>),
|
||||
Uniform2i(i32, i32, i32),
|
||||
Uniform2iv(i32, Vec<i32>),
|
||||
Uniform3f(i32, f32, f32, f32),
|
||||
Uniform3fv(i32, Vec<f32>),
|
||||
Uniform3i(i32, i32, i32, i32),
|
||||
Uniform3iv(i32, Vec<i32>),
|
||||
Uniform4f(i32, f32, f32, f32, f32),
|
||||
Uniform4fv(i32, Vec<f32>),
|
||||
Uniform4i(i32, i32, i32, i32, i32),
|
||||
Uniform4iv(i32, Vec<i32>),
|
||||
UniformMatrix2fv(i32, bool, Vec<f32>),
|
||||
UniformMatrix3fv(i32, bool, Vec<f32>),
|
||||
UniformMatrix4fv(i32, bool, Vec<f32>),
|
||||
UseProgram(WebGLProgramId),
|
||||
ValidateProgram(WebGLProgramId),
|
||||
VertexAttrib(u32, f32, f32, f32, f32),
|
||||
VertexAttribPointer(u32, i32, u32, bool, i32, u32),
|
||||
VertexAttribPointer2f(u32, i32, bool, i32, u32),
|
||||
Viewport(i32, i32, i32, i32),
|
||||
TexImage2D(u32, i32, i32, i32, i32, u32, u32, Vec<u8>),
|
||||
TexParameteri(u32, u32, i32),
|
||||
TexParameterf(u32, u32, f32),
|
||||
TexSubImage2D(u32, i32, i32, i32, i32, i32, u32, u32, Vec<u8>),
|
||||
DrawingBufferWidth(WebGLSender<i32>),
|
||||
DrawingBufferHeight(WebGLSender<i32>),
|
||||
Finish(WebGLSender<()>),
|
||||
Flush,
|
||||
GenerateMipmap(u32),
|
||||
CreateVertexArray(WebGLSender<Option<WebGLVertexArrayId>>),
|
||||
DeleteVertexArray(WebGLVertexArrayId),
|
||||
BindVertexArray(Option<WebGLVertexArrayId>),
|
||||
}
|
||||
|
||||
macro_rules! define_resource_id_struct {
|
||||
($name:ident) => {
|
||||
#[derive(Clone, Copy, Eq, Hash, PartialEq)]
|
||||
pub struct $name(NonZero<u32>);
|
||||
|
||||
impl $name {
|
||||
#[allow(unsafe_code)]
|
||||
#[inline]
|
||||
pub unsafe fn new(id: u32) -> Self {
|
||||
$name(NonZero::new_unchecked(id))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn get(self) -> u32 {
|
||||
self.0.get()
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! define_resource_id {
|
||||
($name:ident) => {
|
||||
define_resource_id_struct!($name);
|
||||
|
||||
#[allow(unsafe_code)]
|
||||
impl<'de> ::serde::Deserialize<'de> for $name {
|
||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||
where D: ::serde::Deserializer<'de>
|
||||
{
|
||||
let id = try!(u32::deserialize(deserializer));
|
||||
if id == 0 {
|
||||
Err(::serde::de::Error::custom("expected a non-zero value"))
|
||||
} else {
|
||||
Ok(unsafe { $name::new(id) })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::serde::Serialize for $name {
|
||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||
where S: ::serde::Serializer
|
||||
{
|
||||
self.get().serialize(serializer)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::std::fmt::Debug for $name {
|
||||
fn fmt(&self, fmt: &mut ::std::fmt::Formatter)
|
||||
-> Result<(), ::std::fmt::Error> {
|
||||
fmt.debug_tuple(stringify!($name))
|
||||
.field(&self.get())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl ::std::fmt::Display for $name {
|
||||
fn fmt(&self, fmt: &mut ::std::fmt::Formatter)
|
||||
-> Result<(), ::std::fmt::Error> {
|
||||
write!(fmt, "{}", self.get())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::heapsize::HeapSizeOf for $name {
|
||||
fn heap_size_of_children(&self) -> usize { 0 }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
define_resource_id!(WebGLBufferId);
|
||||
define_resource_id!(WebGLFramebufferId);
|
||||
define_resource_id!(WebGLRenderbufferId);
|
||||
define_resource_id!(WebGLTextureId);
|
||||
define_resource_id!(WebGLProgramId);
|
||||
define_resource_id!(WebGLShaderId);
|
||||
define_resource_id!(WebGLVertexArrayId);
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
|
||||
pub struct WebGLContextId(pub usize);
|
||||
|
||||
impl ::heapsize::HeapSizeOf for WebGLContextId {
|
||||
fn heap_size_of_children(&self) -> usize { 0 }
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
|
||||
pub enum WebGLError {
|
||||
InvalidEnum,
|
||||
InvalidFramebufferOperation,
|
||||
InvalidOperation,
|
||||
InvalidValue,
|
||||
OutOfMemory,
|
||||
ContextLost,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
pub enum WebGLFramebufferBindingRequest {
|
||||
Explicit(WebGLFramebufferId),
|
||||
Default,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
pub enum WebGLParameter {
|
||||
Int(i32),
|
||||
Bool(bool),
|
||||
String(String),
|
||||
Float(f32),
|
||||
FloatArray(Vec<f32>),
|
||||
Invalid,
|
||||
}
|
||||
|
||||
pub type WebGLResult<T> = Result<T, WebGLError>;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
pub enum WebGLShaderParameter {
|
||||
Int(i32),
|
||||
Bool(bool),
|
||||
Invalid,
|
||||
}
|
||||
|
||||
pub type WebVRDeviceId = u32;
|
||||
|
||||
// WebVR commands that must be called in the WebGL render thread.
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum WebVRCommand {
|
||||
/// Start presenting to a VR device.
|
||||
Create(WebVRDeviceId),
|
||||
/// Synchronize the pose information to be used in the frame.
|
||||
SyncPoses(WebVRDeviceId, f64, f64, WebGLSender<Result<Vec<u8>, ()>>),
|
||||
/// Submit the frame to a VR device using the specified texture coordinates.
|
||||
SubmitFrame(WebVRDeviceId, [f32; 4], [f32; 4]),
|
||||
/// Stop presenting to a VR device
|
||||
Release(WebVRDeviceId)
|
||||
}
|
||||
|
||||
// Trait object that handles WebVR commands.
|
||||
// Receives the texture id and size associated to the WebGLContext.
|
||||
pub trait WebVRRenderHandler: Send {
|
||||
fn handle(&mut self, command: WebVRCommand, texture: Option<(u32, Size2D<i32>)>);
|
||||
}
|
||||
|
||||
impl fmt::Debug for WebGLCommand {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
use self::WebGLCommand::*;
|
||||
let name = match *self {
|
||||
GetContextAttributes(..) => "GetContextAttributes",
|
||||
ActiveTexture(..) => "ActiveTexture",
|
||||
BlendColor(..) => "BlendColor",
|
||||
BlendEquation(..) => "BlendEquation",
|
||||
BlendEquationSeparate(..) => "BlendEquationSeparate",
|
||||
BlendFunc(..) => "BlendFunc",
|
||||
BlendFuncSeparate(..) => "BlendFuncSeparate",
|
||||
AttachShader(..) => "AttachShader",
|
||||
DetachShader(..) => "DetachShader",
|
||||
BindAttribLocation(..) => "BindAttribLocation",
|
||||
BufferData(..) => "BufferData",
|
||||
BufferSubData(..) => "BufferSubData",
|
||||
Clear(..) => "Clear",
|
||||
ClearColor(..) => "ClearColor",
|
||||
ClearDepth(..) => "ClearDepth",
|
||||
ClearStencil(..) => "ClearStencil",
|
||||
ColorMask(..) => "ColorMask",
|
||||
CopyTexImage2D(..) => "CopyTexImage2D",
|
||||
CopyTexSubImage2D(..) => "CopyTexSubImage2D",
|
||||
CullFace(..) => "CullFace",
|
||||
FrontFace(..) => "FrontFace",
|
||||
DepthFunc(..) => "DepthFunc",
|
||||
DepthMask(..) => "DepthMask",
|
||||
DepthRange(..) => "DepthRange",
|
||||
Enable(..) => "Enable",
|
||||
Disable(..) => "Disable",
|
||||
CompileShader(..) => "CompileShader",
|
||||
CreateBuffer(..) => "CreateBuffer",
|
||||
CreateFramebuffer(..) => "CreateFramebuffer",
|
||||
CreateRenderbuffer(..) => "CreateRenderbuffer",
|
||||
CreateTexture(..) => "CreateTexture",
|
||||
CreateProgram(..) => "CreateProgram",
|
||||
CreateShader(..) => "CreateShader",
|
||||
DeleteBuffer(..) => "DeleteBuffer",
|
||||
DeleteFramebuffer(..) => "DeleteFramebuffer",
|
||||
DeleteRenderbuffer(..) => "DeleteRenderBuffer",
|
||||
DeleteTexture(..) => "DeleteTexture",
|
||||
DeleteProgram(..) => "DeleteProgram",
|
||||
DeleteShader(..) => "DeleteShader",
|
||||
BindBuffer(..) => "BindBuffer",
|
||||
BindFramebuffer(..) => "BindFramebuffer",
|
||||
BindRenderbuffer(..) => "BindRenderbuffer",
|
||||
BindTexture(..) => "BindTexture",
|
||||
DisableVertexAttribArray(..) => "DisableVertexAttribArray",
|
||||
DrawArrays(..) => "DrawArrays",
|
||||
DrawElements(..) => "DrawElements",
|
||||
EnableVertexAttribArray(..) => "EnableVertexAttribArray",
|
||||
FramebufferRenderbuffer(..) => "FramebufferRenderbuffer",
|
||||
FramebufferTexture2D(..) => "FramebufferTexture2D",
|
||||
GetBufferParameter(..) => "GetBufferParameter",
|
||||
GetExtensions(..) => "GetExtensions",
|
||||
GetParameter(..) => "GetParameter",
|
||||
GetProgramParameter(..) => "GetProgramParameter",
|
||||
GetShaderParameter(..) => "GetShaderParameter",
|
||||
GetShaderPrecisionFormat(..) => "GetShaderPrecisionFormat",
|
||||
GetActiveAttrib(..) => "GetActiveAttrib",
|
||||
GetActiveUniform(..) => "GetActiveUniform",
|
||||
GetAttribLocation(..) => "GetAttribLocation",
|
||||
GetUniformLocation(..) => "GetUniformLocation",
|
||||
GetShaderInfoLog(..) => "GetShaderInfoLog",
|
||||
GetProgramInfoLog(..) => "GetProgramInfoLog",
|
||||
GetVertexAttrib(..) => "GetVertexAttrib",
|
||||
GetVertexAttribOffset(..) => "GetVertexAttribOffset",
|
||||
PolygonOffset(..) => "PolygonOffset",
|
||||
ReadPixels(..) => "ReadPixels",
|
||||
RenderbufferStorage(..) => "RenderbufferStorage",
|
||||
SampleCoverage(..) => "SampleCoverage",
|
||||
Scissor(..) => "Scissor",
|
||||
StencilFunc(..) => "StencilFunc",
|
||||
StencilFuncSeparate(..) => "StencilFuncSeparate",
|
||||
StencilMask(..) => "StencilMask",
|
||||
StencilMaskSeparate(..) => "StencilMaskSeparate",
|
||||
StencilOp(..) => "StencilOp",
|
||||
StencilOpSeparate(..) => "StencilOpSeparate",
|
||||
Hint(..) => "Hint",
|
||||
IsEnabled(..) => "IsEnabled",
|
||||
LineWidth(..) => "LineWidth",
|
||||
PixelStorei(..) => "PixelStorei",
|
||||
LinkProgram(..) => "LinkProgram",
|
||||
Uniform1f(..) => "Uniform1f",
|
||||
Uniform1fv(..) => "Uniform1fv",
|
||||
Uniform1i(..) => "Uniform1i",
|
||||
Uniform1iv(..) => "Uniform1iv",
|
||||
Uniform2f(..) => "Uniform2f",
|
||||
Uniform2fv(..) => "Uniform2fv",
|
||||
Uniform2i(..) => "Uniform2i",
|
||||
Uniform2iv(..) => "Uniform2iv",
|
||||
Uniform3f(..) => "Uniform3f",
|
||||
Uniform3fv(..) => "Uniform3fv",
|
||||
Uniform3i(..) => "Uniform3i",
|
||||
Uniform3iv(..) => "Uniform3iv",
|
||||
Uniform4f(..) => "Uniform4f",
|
||||
Uniform4fv(..) => "Uniform4fv",
|
||||
Uniform4i(..) => "Uniform4i",
|
||||
Uniform4iv(..) => "Uniform4iv",
|
||||
UniformMatrix2fv(..) => "UniformMatrix2fv",
|
||||
UniformMatrix3fv(..) => "UniformMatrix3fv",
|
||||
UniformMatrix4fv(..) => "UniformMatrix4fv",
|
||||
UseProgram(..) => "UseProgram",
|
||||
ValidateProgram(..) => "ValidateProgram",
|
||||
VertexAttrib(..) => "VertexAttrib",
|
||||
VertexAttribPointer2f(..) => "VertexAttribPointer2f",
|
||||
VertexAttribPointer(..) => "VertexAttribPointer",
|
||||
Viewport(..) => "Viewport",
|
||||
TexImage2D(..) => "TexImage2D",
|
||||
TexParameteri(..) => "TexParameteri",
|
||||
TexParameterf(..) => "TexParameterf",
|
||||
TexSubImage2D(..) => "TexSubImage2D",
|
||||
DrawingBufferWidth(..) => "DrawingBufferWidth",
|
||||
DrawingBufferHeight(..) => "DrawingBufferHeight",
|
||||
Finish(..) => "Finish",
|
||||
Flush => "Flush",
|
||||
GenerateMipmap(..) => "GenerateMipmap",
|
||||
CreateVertexArray(..) => "CreateVertexArray",
|
||||
DeleteVertexArray(..) => "DeleteVertexArray",
|
||||
BindVertexArray(..) => "BindVertexArray"
|
||||
};
|
||||
|
||||
write!(f, "CanvasWebGLMsg::{}(..)", name)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
/* 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 ipc_channel;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::io;
|
||||
|
||||
pub type WebGLSender<T> = ipc_channel::ipc::IpcSender<T>;
|
||||
pub type WebGLReceiver<T> = ipc_channel::ipc::IpcReceiver<T>;
|
||||
|
||||
pub fn webgl_channel<T: Serialize + for<'de> Deserialize<'de>>()
|
||||
-> Result<(WebGLSender<T>, WebGLReceiver<T>), io::Error> {
|
||||
ipc_channel::ipc::channel()
|
||||
}
|
||||
|
|
@ -1,87 +0,0 @@
|
|||
/* 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/. */
|
||||
|
||||
//! Enum wrappers to be able to select different channel implementations at runtime.
|
||||
|
||||
mod ipc;
|
||||
mod mpsc;
|
||||
|
||||
use ::webgl::WebGLMsg;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use servo_config::opts;
|
||||
|
||||
lazy_static! {
|
||||
static ref IS_MULTIPROCESS: bool = {
|
||||
opts::multiprocess()
|
||||
};
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub enum WebGLSender<T: Serialize> {
|
||||
Ipc(ipc::WebGLSender<T>),
|
||||
Mpsc(mpsc::WebGLSender<T>),
|
||||
}
|
||||
|
||||
impl<T: Serialize> WebGLSender<T> {
|
||||
#[inline]
|
||||
pub fn send(&self, msg: T) -> WebGLSendResult {
|
||||
match *self {
|
||||
WebGLSender::Ipc(ref sender) => {
|
||||
sender.send(msg).map_err(|_| ())
|
||||
},
|
||||
WebGLSender::Mpsc(ref sender) => {
|
||||
sender.send(msg).map_err(|_| ())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub type WebGLSendResult = Result<(), ()>;
|
||||
|
||||
pub enum WebGLReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
|
||||
Ipc(ipc::WebGLReceiver<T>),
|
||||
Mpsc(mpsc::WebGLReceiver<T>),
|
||||
}
|
||||
|
||||
impl<T> WebGLReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
|
||||
pub fn recv(&self) -> Result<T, ()> {
|
||||
match *self {
|
||||
WebGLReceiver::Ipc(ref receiver) => {
|
||||
receiver.recv().map_err(|_| ())
|
||||
},
|
||||
WebGLReceiver::Mpsc(ref receiver) => {
|
||||
receiver.recv().map_err(|_| ())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn webgl_channel<T>() -> Result<(WebGLSender<T>, WebGLReceiver<T>), ()>
|
||||
where T: for<'de> Deserialize<'de> + Serialize {
|
||||
if *IS_MULTIPROCESS {
|
||||
ipc::webgl_channel().map(|(tx, rx)| (WebGLSender::Ipc(tx), WebGLReceiver::Ipc(rx)))
|
||||
.map_err(|_| ())
|
||||
} else {
|
||||
mpsc::webgl_channel().map(|(tx, rx)| (WebGLSender::Mpsc(tx), WebGLReceiver::Mpsc(rx)))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct WebGLChan(pub WebGLSender<WebGLMsg>);
|
||||
|
||||
impl WebGLChan {
|
||||
#[inline]
|
||||
pub fn send(&self, msg: WebGLMsg) -> WebGLSendResult {
|
||||
self.0.send(msg)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct WebGLPipeline(pub WebGLChan);
|
||||
|
||||
impl WebGLPipeline {
|
||||
pub fn channel(&self) -> WebGLChan {
|
||||
self.0.clone()
|
||||
}
|
||||
}
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
/* 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 serde::{Deserialize, Serialize};
|
||||
use serde::{Deserializer, Serializer};
|
||||
use std::sync::mpsc;
|
||||
|
||||
#[macro_use]
|
||||
macro_rules! unreachable_serializable {
|
||||
($name:ident) => {
|
||||
impl<T> Serialize for $name<T> {
|
||||
fn serialize<S: Serializer>(&self, _: S) -> Result<S::Ok, S::Error> {
|
||||
unreachable!();
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T> Deserialize<'a> for $name<T> {
|
||||
fn deserialize<D>(_: D) -> Result<$name<T>, D::Error>
|
||||
where D: Deserializer<'a> {
|
||||
unreachable!();
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct WebGLSender<T>(mpsc::Sender<T>);
|
||||
pub struct WebGLReceiver<T>(mpsc::Receiver<T>);
|
||||
|
||||
impl<T> WebGLSender<T> {
|
||||
#[inline]
|
||||
pub fn send(&self, data: T) -> Result<(), mpsc::SendError<T>> {
|
||||
self.0.send(data)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> WebGLReceiver<T> {
|
||||
#[inline]
|
||||
pub fn recv(&self) -> Result<T, mpsc::RecvError> {
|
||||
self.0.recv()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn webgl_channel<T>() -> Result<(WebGLSender<T>, WebGLReceiver<T>), ()> {
|
||||
let (sender, receiver) = mpsc::channel();
|
||||
Ok((WebGLSender(sender), WebGLReceiver(receiver)))
|
||||
}
|
||||
|
||||
unreachable_serializable!(WebGLReceiver);
|
||||
unreachable_serializable!(WebGLSender);
|
||||
Loading…
Add table
Add a link
Reference in a new issue