Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-22 23:03:42 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #21240 - servo:webgl, r=jdm

Browse source 
Properly check for GL object ownership (fixes #21133)

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/21240)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2018-07-24 11:02:57 -04:00 • committed by GitHub
commit 65df9cb73a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 312 additions and 317 deletions
Download patch file Download diff file Expand all files Collapse all files

10
components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs
View file

@ -48,15 +48,7 @@ impl OESVertexArrayObjectMethods for OESVertexArrayObject {
fn CreateVertexArrayOES(&self) -> Option<DomRoot<WebGLVertexArrayObjectOES>> {
let (sender, receiver) = webgl_channel().unwrap();
self.ctx.send_command(WebGLCommand::CreateVertexArray(sender));
let result = receiver.recv().unwrap();
result.map(|vao_id| {
WebGLVertexArrayObjectOES::new(
&self.global(),
vao_id,
self.ctx.limits().max_vertex_attribs,
)
})
receiver.recv().unwrap().map(|id| WebGLVertexArrayObjectOES::new(&self.ctx, id))
}
// https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/

58
components/script/dom/webglbuffer.rs
View file

@ -3,15 +3,16 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
use canvas_traits::webgl::{WebGLBufferId, WebGLCommand, WebGLError, WebGLMsgSender, WebGLResult, WebGLVertexArrayId};
use canvas_traits::webgl::{WebGLBufferId, WebGLCommand, WebGLError, WebGLResult, WebGLVertexArrayId};
use canvas_traits::webgl::webgl_channel;
use dom::bindings::cell::DomRefCell;
use dom::bindings::codegen::Bindings::WebGLBufferBinding;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::inheritance::Castable;
use dom::bindings::reflector::{DomObject, reflect_dom_object};
use dom::bindings::root::DomRoot;
use dom::webglobject::WebGLObject;
use dom::window::Window;
use dom::webglrenderingcontext::WebGLRenderingContext;
use dom_struct::dom_struct;
use std::cell::Cell;
use std::collections::HashSet;
@ -28,44 +29,36 @@ pub struct WebGLBuffer {
// The Vertex Array Objects that are referencing this buffer
vao_references: DomRefCell<Option<HashSet<WebGLVertexArrayId>>>,
pending_delete: Cell<bool>,
#[ignore_malloc_size_of = "Defined in ipc-channel"]
renderer: WebGLMsgSender,
/// https://www.khronos.org/registry/OpenGL-Refpages/es2.0/xhtml/glGetBufferParameteriv.xml
usage: Cell<u32>,
}
impl WebGLBuffer {
fn new_inherited(renderer: WebGLMsgSender,
id: WebGLBufferId)
-> WebGLBuffer {
WebGLBuffer {
webgl_object: WebGLObject::new_inherited(),
fn new_inherited(context: &WebGLRenderingContext, id: WebGLBufferId) -> Self {
Self {
webgl_object: WebGLObject::new_inherited(context),
id: id,
target: Cell::new(None),
capacity: Cell::new(0),
is_deleted: Cell::new(false),
vao_references: DomRefCell::new(None),
pending_delete: Cell::new(false),
renderer: renderer,
usage: Cell::new(WebGLRenderingContextConstants::STATIC_DRAW),
}
}
pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
-> Option<DomRoot<WebGLBuffer>> {
pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
let (sender, receiver) = webgl_channel().unwrap();
renderer.send(WebGLCommand::CreateBuffer(sender)).unwrap();
let result = receiver.recv().unwrap();
result.map(|buffer_id| WebGLBuffer::new(window, renderer, buffer_id))
context.send_command(WebGLCommand::CreateBuffer(sender));
receiver.recv().unwrap().map(|id| WebGLBuffer::new(context, id))
}
pub fn new(window: &Window,
renderer: WebGLMsgSender,
id: WebGLBufferId)
-> DomRoot<WebGLBuffer> {
reflect_dom_object(Box::new(WebGLBuffer::new_inherited(renderer, id)),
window, WebGLBufferBinding::Wrap)
pub fn new(context: &WebGLRenderingContext, id: WebGLBufferId) -> DomRoot<Self> {
reflect_dom_object(
Box::new(WebGLBuffer::new_inherited(context, id)),
&*context.global(),
WebGLBufferBinding::Wrap,
)
}
}
@ -87,9 +80,9 @@ impl WebGLBuffer {
} else {
self.target.set(Some(target));
}
let msg = WebGLCommand::BindBuffer(target, Some(self.id));
self.renderer.send(msg).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::BindBuffer(target, Some(self.id)));
Ok(())
}
@ -112,8 +105,9 @@ impl WebGLBuffer {
let data = data.into();
self.capacity.set(data.len());
self.usage.set(usage);
self.renderer.send(WebGLCommand::BufferData(target, data.into(), usage)).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::BufferData(target, data.into(), usage));
Ok(())
}
@ -124,7 +118,9 @@ impl WebGLBuffer {
pub fn delete(&self) {
if !self.is_deleted.get() {
self.is_deleted.set(true);
let _ = self.renderer.send(WebGLCommand::DeleteBuffer(self.id));
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::DeleteBuffer(self.id));
}
}
@ -164,7 +160,9 @@ impl WebGLBuffer {
if let Some(ref mut vao_refs) = *self.vao_references.borrow_mut() {
if vao_refs.take(&id).is_some() && self.pending_delete.get() {
// WebGL spec: The deleted buffers should no longer be valid when the VAOs are deleted
let _ = self.renderer.send(WebGLCommand::DeleteBuffer(self.id));
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::DeleteBuffer(self.id));
self.is_deleted.set(true);
}
}

80
components/script/dom/webglframebuffer.rs
View file

@ -4,17 +4,17 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
use canvas_traits::webgl::{WebGLCommand, WebGLFramebufferBindingRequest, WebGLFramebufferId};
use canvas_traits::webgl::{WebGLMsgSender, WebGLResult, WebGLError};
use canvas_traits::webgl::webgl_channel;
use canvas_traits::webgl::{WebGLResult, WebGLError, webgl_channel};
use dom::bindings::cell::DomRefCell;
use dom::bindings::codegen::Bindings::WebGLFramebufferBinding;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::inheritance::Castable;
use dom::bindings::reflector::{DomObject, reflect_dom_object};
use dom::bindings::root::{Dom, DomRoot};
use dom::webglobject::WebGLObject;
use dom::webglrenderbuffer::WebGLRenderbuffer;
use dom::webglrenderingcontext::WebGLRenderingContext;
use dom::webgltexture::WebGLTexture;
use dom::window::Window;
use dom_struct::dom_struct;
use std::cell::Cell;
@ -40,9 +40,6 @@ pub struct WebGLFramebuffer {
is_deleted: Cell<bool>,
size: Cell<Option<(i32, i32)>>,
status: Cell<u32>,
#[ignore_malloc_size_of = "Defined in ipc-channel"]
renderer: WebGLMsgSender,
// The attachment points for textures and renderbuffers on this
// FBO.
color: DomRefCell<Option<WebGLFramebufferAttachment>>,
@ -52,15 +49,12 @@ pub struct WebGLFramebuffer {
}
impl WebGLFramebuffer {
fn new_inherited(renderer: WebGLMsgSender,
id: WebGLFramebufferId)
-> WebGLFramebuffer {
WebGLFramebuffer {
webgl_object: WebGLObject::new_inherited(),
fn new_inherited(context: &WebGLRenderingContext, id: WebGLFramebufferId) -> Self {
Self {
webgl_object: WebGLObject::new_inherited(context),
id: id,
target: Cell::new(None),
is_deleted: Cell::new(false),
renderer: renderer,
size: Cell::new(None),
status: Cell::new(constants::FRAMEBUFFER_UNSUPPORTED),
color: DomRefCell::new(None),
@ -70,22 +64,21 @@ impl WebGLFramebuffer {
}
}
pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
-> Option<DomRoot<WebGLFramebuffer>> {
pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
let (sender, receiver) = webgl_channel().unwrap();
renderer.send(WebGLCommand::CreateFramebuffer(sender)).unwrap();
let result = receiver.recv().unwrap();
result.map(|fb_id| WebGLFramebuffer::new(window, renderer, fb_id))
context.send_command(WebGLCommand::CreateFramebuffer(sender));
receiver.recv().unwrap().map(|id| WebGLFramebuffer::new(context, id))
}
pub fn new(window: &Window,
renderer: WebGLMsgSender,
id: WebGLFramebufferId)
-> DomRoot<WebGLFramebuffer> {
reflect_dom_object(Box::new(WebGLFramebuffer::new_inherited(renderer, id)),
window,
WebGLFramebufferBinding::Wrap)
pub fn new(
context: &WebGLRenderingContext,
id: WebGLFramebufferId,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(WebGLFramebuffer::new_inherited(context, id)),
&*context.global(),
WebGLFramebufferBinding::Wrap,
)
}
}
@ -102,14 +95,17 @@ impl WebGLFramebuffer {
self.update_status();
self.target.set(Some(target));
let cmd = WebGLCommand::BindFramebuffer(target, WebGLFramebufferBindingRequest::Explicit(self.id));
self.renderer.send(cmd).unwrap();
self.upcast::<WebGLObject>().context().send_command(
WebGLCommand::BindFramebuffer(target, WebGLFramebufferBindingRequest::Explicit(self.id)),
);
}
pub fn delete(&self) {
if !self.is_deleted.get() {
self.is_deleted.set(true);
let _ = self.renderer.send(WebGLCommand::DeleteFramebuffer(self.id));
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::DeleteFramebuffer(self.id));
}
}
@ -210,10 +206,14 @@ impl WebGLFramebuffer {
}
};
self.renderer.send(WebGLCommand::FramebufferRenderbuffer(constants::FRAMEBUFFER,
attachment,
constants::RENDERBUFFER,
rb_id)).unwrap();
self.upcast::<WebGLObject>().context().send_command(
WebGLCommand::FramebufferRenderbuffer(
constants::FRAMEBUFFER,
attachment,
constants::RENDERBUFFER,
rb_id,
),
);
self.update_status();
Ok(())
@ -305,11 +305,15 @@ impl WebGLFramebuffer {
}
};
self.renderer.send(WebGLCommand::FramebufferTexture2D(constants::FRAMEBUFFER,
attachment,
textarget,
tex_id,
level)).unwrap();
self.upcast::<WebGLObject>().context().send_command(
WebGLCommand::FramebufferTexture2D(
constants::FRAMEBUFFER,
attachment,
textarget,
tex_id,
level,
),
);
self.update_status();
Ok(())

10
components/script/dom/webglobject.rs
View file

@ -4,17 +4,25 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
use dom::bindings::reflector::Reflector;
use dom::bindings::root::Dom;
use dom::webglrenderingcontext::WebGLRenderingContext;
use dom_struct::dom_struct;
#[dom_struct]
pub struct WebGLObject {
reflector_: Reflector,
context: Dom<WebGLRenderingContext>,
}
impl WebGLObject {
pub fn new_inherited() -> WebGLObject {
pub fn new_inherited(context: &WebGLRenderingContext) -> WebGLObject {
WebGLObject {
reflector_: Reflector::new(),
context: Dom::from_ref(context),
}
}
pub fn context(&self) -> &WebGLRenderingContext {
&self.context
}
}

71
components/script/dom/webglprogram.rs
View file

@ -4,19 +4,19 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
use canvas_traits::webgl::{ActiveAttribInfo, ActiveUniformInfo, WebGLCommand, WebGLError};
use canvas_traits::webgl::{WebGLMsgSender, WebGLProgramId, WebGLResult, webgl_channel};
use canvas_traits::webgl::{WebGLProgramId, WebGLResult, webgl_channel};
use dom::bindings::cell::DomRefCell;
use dom::bindings::codegen::Bindings::WebGLProgramBinding;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
use dom::bindings::inheritance::Castable;
use dom::bindings::reflector::{DomObject, reflect_dom_object};
use dom::bindings::root::{DomRoot, MutNullableDom};
use dom::bindings::str::DOMString;
use dom::webglactiveinfo::WebGLActiveInfo;
use dom::webglobject::WebGLObject;
use dom::webglrenderingcontext::MAX_UNIFORM_AND_ATTRIBUTE_LEN;
use dom::webglrenderingcontext::{MAX_UNIFORM_AND_ATTRIBUTE_LEN, WebGLRenderingContext};
use dom::webglshader::WebGLShader;
use dom::webgluniformlocation::WebGLUniformLocation;
use dom::window::Window;
use dom_struct::dom_struct;
use fnv::FnvHashSet;
use std::cell::{Cell, Ref};
@ -31,16 +31,14 @@ pub struct WebGLProgram {
link_generation: Cell<u64>,
fragment_shader: MutNullableDom<WebGLShader>,
vertex_shader: MutNullableDom<WebGLShader>,
#[ignore_malloc_size_of = "Defined in ipc-channel"]
renderer: WebGLMsgSender,
active_attribs: DomRefCell<Box<[ActiveAttribInfo]>>,
active_uniforms: DomRefCell<Box<[ActiveUniformInfo]>>,
}
impl WebGLProgram {
fn new_inherited(renderer: WebGLMsgSender, id: WebGLProgramId) -> Self {
fn new_inherited(context: &WebGLRenderingContext, id: WebGLProgramId) -> Self {
Self {
webgl_object: WebGLObject::new_inherited(),
webgl_object: WebGLObject::new_inherited(context),
id: id,
is_deleted: Cell::new(false),
link_called: Cell::new(false),
@ -48,28 +46,23 @@ impl WebGLProgram {
link_generation: Default::default(),
fragment_shader: Default::default(),
vertex_shader: Default::default(),
renderer: renderer,
active_attribs: DomRefCell::new(vec![].into()),
active_uniforms: DomRefCell::new(vec![].into()),
}
}
pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
-> Option<DomRoot<WebGLProgram>> {
pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
let (sender, receiver) = webgl_channel().unwrap();
renderer.send(WebGLCommand::CreateProgram(sender)).unwrap();
let result = receiver.recv().unwrap();
result.map(|program_id| WebGLProgram::new(window, renderer, program_id))
context.send_command(WebGLCommand::CreateProgram(sender));
receiver.recv().unwrap().map(|id| WebGLProgram::new(context, id))
}
pub fn new(window: &Window,
renderer: WebGLMsgSender,
id: WebGLProgramId)
-> DomRoot<WebGLProgram> {
reflect_dom_object(Box::new(WebGLProgram::new_inherited(renderer, id)),
window,
WebGLProgramBinding::Wrap)
pub fn new(context: &WebGLRenderingContext, id: WebGLProgramId) -> DomRoot<Self> {
reflect_dom_object(
Box::new(WebGLProgram::new_inherited(context, id)),
&*context.global(),
WebGLProgramBinding::Wrap,
)
}
}
@ -83,7 +76,9 @@ impl WebGLProgram {
pub fn delete(&self) {
if !self.is_deleted.get() {
self.is_deleted.set(true);
let _ = self.renderer.send(WebGLCommand::DeleteProgram(self.id));
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::DeleteProgram(self.id));
if let Some(shader) = self.fragment_shader.get() {
shader.decrement_attached_counter();
@ -124,7 +119,9 @@ impl WebGLProgram {
}
let (sender, receiver) = webgl_channel().unwrap();
self.renderer.send(WebGLCommand::LinkProgram(self.id, sender)).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::LinkProgram(self.id, sender));
let link_info = receiver.recv().unwrap();
{
@ -175,7 +172,9 @@ impl WebGLProgram {
if self.is_deleted() {
return Err(WebGLError::InvalidOperation);
}
self.renderer.send(WebGLCommand::ValidateProgram(self.id)).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::ValidateProgram(self.id));
Ok(())
}
@ -202,7 +201,9 @@ impl WebGLProgram {
shader_slot.set(Some(shader));
shader.increment_attached_counter();
self.renderer.send(WebGLCommand::AttachShader(self.id, shader.id())).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::AttachShader(self.id, shader.id()));
Ok(())
}
@ -232,7 +233,9 @@ impl WebGLProgram {
shader_slot.set(None);
shader.decrement_attached_counter();
self.renderer.send(WebGLCommand::DetachShader(self.id, shader.id())).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::DetachShader(self.id, shader.id()));
Ok(())
}
@ -251,9 +254,9 @@ impl WebGLProgram {
return Err(WebGLError::InvalidOperation);
}
self.renderer
.send(WebGLCommand::BindAttribLocation(self.id, index, name.into()))
.unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::BindAttribLocation(self.id, index, name.into()));
Ok(())
}
@ -351,9 +354,9 @@ impl WebGLProgram {
};
let (sender, receiver) = webgl_channel().unwrap();
self.renderer
.send(WebGLCommand::GetUniformLocation(self.id, name.into(), sender))
.unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::GetUniformLocation(self.id, name.into(), sender));
let location = receiver.recv().unwrap();
Ok(Some(WebGLUniformLocation::new(
@ -381,7 +384,9 @@ impl WebGLProgram {
}
}
let (sender, receiver) = webgl_channel().unwrap();
self.renderer.send(WebGLCommand::GetProgramInfoLog(self.id, sender)).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::GetProgramInfoLog(self.id, sender));
Ok(receiver.recv().unwrap())
}

59
components/script/dom/webglrenderbuffer.rs
View file

@ -3,13 +3,14 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
use canvas_traits::webgl::{webgl_channel, WebGLCommand, WebGLError, WebGLMsgSender, WebGLRenderbufferId, WebGLResult};
use canvas_traits::webgl::{webgl_channel, WebGLCommand, WebGLError, WebGLRenderbufferId, WebGLResult};
use dom::bindings::codegen::Bindings::WebGLRenderbufferBinding;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::inheritance::Castable;
use dom::bindings::reflector::{DomObject, reflect_dom_object};
use dom::bindings::root::DomRoot;
use dom::webglobject::WebGLObject;
use dom::window::Window;
use dom::webglrenderingcontext::WebGLRenderingContext;
use dom_struct::dom_struct;
use std::cell::Cell;
@ -21,41 +22,32 @@ pub struct WebGLRenderbuffer {
is_deleted: Cell<bool>,
size: Cell<Option<(i32, i32)>>,
internal_format: Cell<Option<u32>>,
#[ignore_malloc_size_of = "Defined in ipc-channel"]
renderer: WebGLMsgSender,
}
impl WebGLRenderbuffer {
fn new_inherited(renderer: WebGLMsgSender,
id: WebGLRenderbufferId)
-> WebGLRenderbuffer {
WebGLRenderbuffer {
webgl_object: WebGLObject::new_inherited(),
fn new_inherited(context: &WebGLRenderingContext, id: WebGLRenderbufferId) -> Self {
Self {
webgl_object: WebGLObject::new_inherited(context),
id: id,
ever_bound: Cell::new(false),
is_deleted: Cell::new(false),
renderer: renderer,
internal_format: Cell::new(None),
size: Cell::new(None),
}
}
pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
-> Option<DomRoot<WebGLRenderbuffer>> {
pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
let (sender, receiver) = webgl_channel().unwrap();
renderer.send(WebGLCommand::CreateRenderbuffer(sender)).unwrap();
let result = receiver.recv().unwrap();
result.map(|renderbuffer_id| WebGLRenderbuffer::new(window, renderer, renderbuffer_id))
context.send_command(WebGLCommand::CreateRenderbuffer(sender));
receiver.recv().unwrap().map(|id| WebGLRenderbuffer::new(context, id))
}
pub fn new(window: &Window,
renderer: WebGLMsgSender,
id: WebGLRenderbufferId)
-> DomRoot<WebGLRenderbuffer> {
reflect_dom_object(Box::new(WebGLRenderbuffer::new_inherited(renderer, id)),
window,
WebGLRenderbufferBinding::Wrap)
pub fn new(context: &WebGLRenderingContext, id: WebGLRenderbufferId) -> DomRoot<Self> {
reflect_dom_object(
Box::new(WebGLRenderbuffer::new_inherited(context, id)),
&*context.global(),
WebGLRenderbufferBinding::Wrap,
)
}
}
@ -71,14 +63,17 @@ impl WebGLRenderbuffer {
pub fn bind(&self, target: u32) {
self.ever_bound.set(true);
let msg = WebGLCommand::BindRenderbuffer(target, Some(self.id));
self.renderer.send(msg).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::BindRenderbuffer(target, Some(self.id)));
}
pub fn delete(&self) {
if !self.is_deleted.get() {
self.is_deleted.set(true);
let _ = self.renderer.send(WebGLCommand::DeleteRenderbuffer(self.id));
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::DeleteRenderbuffer(self.id));
}
}
@ -108,8 +103,14 @@ impl WebGLRenderbuffer {
// FIXME: Invalidate completeness after the call
let msg = WebGLCommand::RenderbufferStorage(constants::RENDERBUFFER, internal_format, width, height);
self.renderer.send(msg).unwrap();
self.upcast::<WebGLObject>().context().send_command(
WebGLCommand::RenderbufferStorage(
constants::RENDERBUFFER,
internal_format,
width,
height,
)
);
self.size.set(Some((width, height)));

111
components/script/dom/webglrenderingcontext.rs
View file

@ -21,7 +21,7 @@ use dom::bindings::codegen::UnionTypes::ArrayBufferViewOrArrayBuffer;
use dom::bindings::codegen::UnionTypes::Float32ArrayOrUnrestrictedFloatSequence;
use dom::bindings::codegen::UnionTypes::ImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement;
use dom::bindings::codegen::UnionTypes::Int32ArrayOrLongSequence;
use dom::bindings::conversions::ToJSValConvertible;
use dom::bindings::conversions::{DerivedFrom, ToJSValConvertible};
use dom::bindings::error::{Error, ErrorResult};
use dom::bindings::inheritance::Castable;
use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object};
@ -41,6 +41,7 @@ use dom::webglactiveinfo::WebGLActiveInfo;
use dom::webglbuffer::WebGLBuffer;
use dom::webglcontextevent::WebGLContextEvent;
use dom::webglframebuffer::{WebGLFramebuffer, WebGLFramebufferAttachmentRoot};
use dom::webglobject::WebGLObject;
use dom::webglprogram::WebGLProgram;
use dom::webglrenderbuffer::WebGLRenderbuffer;
use dom::webglshader::WebGLShader;
@ -427,6 +428,16 @@ impl WebGLRenderingContext {
}
}
fn validate_ownership<T>(&self, object: &T) -> WebGLResult<()>
where
T: DerivedFrom<WebGLObject>,
{
if self != object.upcast().context() {
return Err(InvalidOperation);
}
Ok(())
}
fn with_location<F>(&self, location: Option<&WebGLUniformLocation>, f: F)
where
F: FnOnce(&WebGLUniformLocation) -> WebGLResult<()>,
@ -1766,21 +1777,30 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn AttachShader(&self, program: &WebGLProgram, shader: &WebGLShader) {
handle_potential_webgl_error!(self, self.validate_ownership(program), return);
handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
handle_potential_webgl_error!(self, program.attach_shader(shader));
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn DetachShader(&self, program: &WebGLProgram, shader: &WebGLShader) {
handle_potential_webgl_error!(self, self.validate_ownership(program), return);
handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
handle_potential_webgl_error!(self, program.detach_shader(shader));
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn BindAttribLocation(&self, program: &WebGLProgram, index: u32, name: DOMString) {
handle_potential_webgl_error!(self, self.validate_ownership(program), return);
handle_potential_webgl_error!(self, program.bind_attrib_location(index, name));
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
fn BindBuffer(&self, target: u32, buffer: Option<&WebGLBuffer>) {
if let Some(buffer) = buffer {
handle_potential_webgl_error!(self, self.validate_ownership(buffer), return);
}
let slot = match target {
constants::ARRAY_BUFFER => &self.bound_buffer_array,
constants::ELEMENT_ARRAY_BUFFER => &self.bound_buffer_element_array,
@ -1802,6 +1822,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
fn BindFramebuffer(&self, target: u32, framebuffer: Option<&WebGLFramebuffer>) {
if let Some(fb) = framebuffer {
handle_potential_webgl_error!(self, self.validate_ownership(fb), return);
}
if target != constants::FRAMEBUFFER {
return self.webgl_error(InvalidEnum);
}
@ -1828,6 +1852,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
fn BindRenderbuffer(&self, target: u32, renderbuffer: Option<&WebGLRenderbuffer>) {
if let Some(rb) = renderbuffer {
handle_potential_webgl_error!(self, self.validate_ownership(rb), return);
}
if target != constants::RENDERBUFFER {
return self.webgl_error(InvalidEnum);
}
@ -1850,6 +1878,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
fn BindTexture(&self, target: u32, texture: Option<&WebGLTexture>) {
if let Some(texture) = texture {
handle_potential_webgl_error!(self, self.validate_ownership(texture), return);
}
let mut bound_textures = self.bound_textures.borrow_mut();
let binding = bound_textures.entry(self.bound_texture_unit.get())
.or_insert(TextureUnitBindings::new());
@ -2175,6 +2207,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn CompileShader(&self, shader: &WebGLShader) {
handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
handle_potential_webgl_error!(
self,
shader.compile(
@ -2186,31 +2219,29 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
)
}
// TODO(emilio): Probably in the future we should keep track of the
// generated objects, either here or in the webgl thread
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
fn CreateBuffer(&self) -> Option<DomRoot<WebGLBuffer>> {
WebGLBuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone())
WebGLBuffer::maybe_new(self)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
fn CreateFramebuffer(&self) -> Option<DomRoot<WebGLFramebuffer>> {
WebGLFramebuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone())
WebGLFramebuffer::maybe_new(self)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
fn CreateRenderbuffer(&self) -> Option<DomRoot<WebGLRenderbuffer>> {
WebGLRenderbuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone())
WebGLRenderbuffer::maybe_new(self)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
fn CreateTexture(&self) -> Option<DomRoot<WebGLTexture>> {
WebGLTexture::maybe_new(self.global().as_window(), self.webgl_sender.clone())
WebGLTexture::maybe_new(self)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn CreateProgram(&self) -> Option<DomRoot<WebGLProgram>> {
WebGLProgram::maybe_new(self.global().as_window(), self.webgl_sender.clone())
WebGLProgram::maybe_new(self)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
@ -2222,12 +2253,14 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
return None;
}
}
WebGLShader::maybe_new(self.global().as_window(), self.webgl_sender.clone(), shader_type)
WebGLShader::maybe_new(self, shader_type)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
fn DeleteBuffer(&self, buffer: Option<&WebGLBuffer>) {
if let Some(buffer) = buffer {
handle_potential_webgl_error!(self, self.validate_ownership(buffer), return);
if buffer.is_attached_to_vao() {
// WebGL spec: The buffers attached to VAOs should still not be deleted.
// They are deleted after the VAO is deleted.
@ -2250,6 +2283,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
fn DeleteFramebuffer(&self, framebuffer: Option<&WebGLFramebuffer>) {
if let Some(framebuffer) = framebuffer {
handle_potential_webgl_error!(self, self.validate_ownership(framebuffer), return);
handle_object_deletion!(self, self.bound_framebuffer, framebuffer,
Some(WebGLCommand::BindFramebuffer(constants::FRAMEBUFFER,
WebGLFramebufferBindingRequest::Default)));
@ -2260,6 +2294,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
fn DeleteRenderbuffer(&self, renderbuffer: Option<&WebGLRenderbuffer>) {
if let Some(renderbuffer) = renderbuffer {
handle_potential_webgl_error!(self, self.validate_ownership(renderbuffer), return);
handle_object_deletion!(self, self.bound_renderbuffer, renderbuffer,
Some(WebGLCommand::BindRenderbuffer(constants::RENDERBUFFER, None)));
// From the GLES 2.0.25 spec, page 113:
@ -2283,6 +2318,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
fn DeleteTexture(&self, texture: Option<&WebGLTexture>) {
if let Some(texture) = texture {
handle_potential_webgl_error!(self, self.validate_ownership(texture), return);
// From the GLES 2.0.25 spec, page 85:
//
// "If a texture that is currently bound to one of the targets
@ -2325,6 +2362,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn DeleteProgram(&self, program: Option<&WebGLProgram>) {
if let Some(program) = program {
handle_potential_webgl_error!(self, self.validate_ownership(program), return);
// FIXME: We should call glUseProgram(0), but
// WebGLCommand::UseProgram() doesn't take an Option
// currently. This is also a problem for useProgram(null)
@ -2336,6 +2374,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn DeleteShader(&self, shader: Option<&WebGLShader>) {
if let Some(shader) = shader {
handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
shader.delete()
}
}
@ -2477,6 +2516,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
fn GetActiveUniform(&self, program: &WebGLProgram, index: u32) -> Option<DomRoot<WebGLActiveInfo>> {
handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
match program.get_active_uniform(index) {
Ok(ret) => Some(ret),
Err(e) => {
@ -2488,11 +2528,13 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
fn GetActiveAttrib(&self, program: &WebGLProgram, index: u32) -> Option<DomRoot<WebGLActiveInfo>> {
handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
handle_potential_webgl_error!(self, program.get_active_attrib(index).map(Some), None)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
fn GetAttribLocation(&self, program: &WebGLProgram, name: DOMString) -> i32 {
handle_potential_webgl_error!(self, self.validate_ownership(program), return -1);
handle_potential_webgl_error!(self, program.get_attrib_location(name), -1)
}
@ -2653,6 +2695,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn GetProgramInfoLog(&self, program: &WebGLProgram) -> Option<DOMString> {
handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
match program.get_info_log() {
Ok(value) => Some(DOMString::from(value)),
Err(e) => {
@ -2665,7 +2708,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
#[allow(unsafe_code)]
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
unsafe fn GetProgramParameter(&self, _: *mut JSContext, program: &WebGLProgram, param: u32) -> JSVal {
// FIXME(nox): INVALID_OPERATION if program comes from a different context.
handle_potential_webgl_error!(self, self.validate_ownership(program), return NullValue());
match param {
constants::DELETE_STATUS => BooleanValue(program.is_deleted()),
constants::LINK_STATUS => BooleanValue(program.is_linked()),
@ -2691,13 +2734,14 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn GetShaderInfoLog(&self, shader: &WebGLShader) -> Option<DOMString> {
// TODO(nox): https://github.com/servo/servo/issues/21133
handle_potential_webgl_error!(self, self.validate_ownership(shader), return None);
Some(shader.info_log())
}
#[allow(unsafe_code)]
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
unsafe fn GetShaderParameter(&self, _: *mut JSContext, shader: &WebGLShader, param: u32) -> JSVal {
handle_potential_webgl_error!(self, self.validate_ownership(shader), return NullValue());
if shader.is_deleted() && !shader.is_attached() {
self.webgl_error(InvalidValue);
return NullValue();
@ -2750,6 +2794,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
program: &WebGLProgram,
name: DOMString,
) -> Option<DomRoot<WebGLUniformLocation>> {
handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
handle_potential_webgl_error!(self, program.get_uniform_location(name), None)
}
@ -3136,18 +3181,19 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn LinkProgram(&self, program: &WebGLProgram) {
// FIXME(nox): INVALID_OPERATION if program comes from a different context.
handle_potential_webgl_error!(self, self.validate_ownership(program), return);
handle_potential_webgl_error!(self, program.link());
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn ShaderSource(&self, shader: &WebGLShader, source: DOMString) {
handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
shader.set_source(source)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn GetShaderSource(&self, shader: &WebGLShader) -> Option<DOMString> {
// TODO(nox): https://github.com/servo/servo/issues/21133
handle_potential_webgl_error!(self, self.validate_ownership(shader), return None);
Some(shader.source())
}
@ -3613,7 +3659,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
program: &WebGLProgram,
location: &WebGLUniformLocation,
) -> JSVal {
// FIXME(nox): https://github.com/servo/servo/issues/21133
handle_potential_webgl_error!(self, self.validate_ownership(program), return NullValue());
if
program.is_deleted() ||
@ -3687,6 +3733,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn UseProgram(&self, program: Option<&WebGLProgram>) {
if let Some(program) = program {
handle_potential_webgl_error!(self, self.validate_ownership(program), return);
if program.is_deleted() || !program.is_linked() {
return self.webgl_error(InvalidOperation);
}
@ -3697,6 +3744,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn ValidateProgram(&self, program: &WebGLProgram) {
handle_potential_webgl_error!(self, self.validate_ownership(program), return);
if let Err(e) = program.validate() {
self.webgl_error(e);
}
@ -4135,9 +4183,17 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
fn FramebufferRenderbuffer(&self, target: u32, attachment: u32,
renderbuffertarget: u32,
rb: Option<&WebGLRenderbuffer>) {
fn FramebufferRenderbuffer(
&self,
target: u32,
attachment: u32,
renderbuffertarget: u32,
rb: Option<&WebGLRenderbuffer>,
) {
if let Some(rb) = rb {
handle_potential_webgl_error!(self, self.validate_ownership(rb), return);
}
if target != constants::FRAMEBUFFER || renderbuffertarget != constants::RENDERBUFFER {
return self.webgl_error(InvalidEnum);
}
@ -4149,9 +4205,18 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
fn FramebufferTexture2D(&self, target: u32, attachment: u32,
textarget: u32, texture: Option<&WebGLTexture>,
level: i32) {
fn FramebufferTexture2D(
&self,
target: u32,
attachment: u32,
textarget: u32,
texture: Option<&WebGLTexture>,
level: i32,
) {
if let Some(texture) = texture {
handle_potential_webgl_error!(self, self.validate_ownership(texture), return);
}
if target != constants::FRAMEBUFFER {
return self.webgl_error(InvalidEnum);
}
@ -4163,10 +4228,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
}
/// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn GetAttachedShaders(
&self,
program: &WebGLProgram,
) -> Option<Vec<DomRoot<WebGLShader>>> {
fn GetAttachedShaders(&self, program: &WebGLProgram) -> Option<Vec<DomRoot<WebGLShader>>> {
handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
handle_potential_webgl_error!(self, program.attached_shaders().map(Some), None)
}
}

61
components/script/dom/webglshader.rs
View file

@ -3,19 +3,20 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
use canvas_traits::webgl::{WebGLCommand, WebGLError, WebGLMsgSender};
use canvas_traits::webgl::{WebGLCommand, WebGLError};
use canvas_traits::webgl::{WebGLResult, WebGLSLVersion, WebGLShaderId};
use canvas_traits::webgl::{WebGLVersion, webgl_channel};
use dom::bindings::cell::DomRefCell;
use dom::bindings::codegen::Bindings::WebGLShaderBinding;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::inheritance::Castable;
use dom::bindings::reflector::{DomObject, reflect_dom_object};
use dom::bindings::root::DomRoot;
use dom::bindings::str::DOMString;
use dom::webgl_extensions::WebGLExtensions;
use dom::webgl_extensions::ext::extshadertexturelod::EXTShaderTextureLod;
use dom::webgl_extensions::ext::oesstandardderivatives::OESStandardDerivatives;
use dom::webglobject::WebGLObject;
use dom::window::Window;
use dom::webglrenderingcontext::WebGLRenderingContext;
use dom_struct::dom_struct;
use mozangle::shaders::{BuiltInResources, Output, ShaderValidator};
use offscreen_gl_context::GLLimits;
@ -40,20 +41,19 @@ pub struct WebGLShader {
is_deleted: Cell<bool>,
attached_counter: Cell<u32>,
compilation_status: Cell<ShaderCompilationStatus>,
#[ignore_malloc_size_of = "Defined in ipc-channel"]
renderer: WebGLMsgSender,
}
static GLSLANG_INITIALIZATION: Once = ONCE_INIT;
impl WebGLShader {
fn new_inherited(renderer: WebGLMsgSender,
id: WebGLShaderId,
shader_type: u32)
-> WebGLShader {
fn new_inherited(
context: &WebGLRenderingContext,
id: WebGLShaderId,
shader_type: u32,
) -> Self {
GLSLANG_INITIALIZATION.call_once(|| ::mozangle::shaders::initialize().unwrap());
WebGLShader {
webgl_object: WebGLObject::new_inherited(),
Self {
webgl_object: WebGLObject::new_inherited(context),
id: id,
gl_type: shader_type,
source: Default::default(),
@ -61,29 +61,25 @@ impl WebGLShader {
is_deleted: Cell::new(false),
attached_counter: Cell::new(0),
compilation_status: Cell::new(ShaderCompilationStatus::NotCompiled),
renderer: renderer,
}
}
pub fn maybe_new(window: &Window,
renderer: WebGLMsgSender,
shader_type: u32)
-> Option<DomRoot<WebGLShader>> {
pub fn maybe_new(context: &WebGLRenderingContext, shader_type: u32) -> Option<DomRoot<Self>> {
let (sender, receiver) = webgl_channel().unwrap();
renderer.send(WebGLCommand::CreateShader(shader_type, sender)).unwrap();
let result = receiver.recv().unwrap();
result.map(|shader_id| WebGLShader::new(window, renderer, shader_id, shader_type))
context.send_command(WebGLCommand::CreateShader(shader_type, sender));
receiver.recv().unwrap().map(|id| WebGLShader::new(context, id, shader_type))
}
pub fn new(window: &Window,
renderer: WebGLMsgSender,
id: WebGLShaderId,
shader_type: u32)
-> DomRoot<WebGLShader> {
reflect_dom_object(Box::new(WebGLShader::new_inherited(renderer, id, shader_type)),
window,
WebGLShaderBinding::Wrap)
pub fn new(
context: &WebGLRenderingContext,
id: WebGLShaderId,
shader_type: u32,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(WebGLShader::new_inherited(context, id, shader_type)),
&*context.global(),
WebGLShaderBinding::Wrap,
)
}
}
@ -168,8 +164,9 @@ impl WebGLShader {
// NOTE: At this point we should be pretty sure that the compilation in the paint thread
// will succeed.
// It could be interesting to retrieve the info log from the paint thread though
let msg = WebGLCommand::CompileShader(self.id, translated_source);
self.renderer.send(msg).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::CompileShader(self.id, translated_source));
self.compilation_status.set(ShaderCompilationStatus::Succeeded);
},
Err(error) => {
@ -194,7 +191,9 @@ impl WebGLShader {
pub fn delete(&self) {
if !self.is_deleted.get() {
self.is_deleted.set(true);
let _ = self.renderer.send(WebGLCommand::DeleteShader(self.id));
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::DeleteShader(self.id));
}
}

80
components/script/dom/webgltexture.rs
View file

@ -5,16 +5,17 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
use canvas_traits::webgl::{DOMToTextureCommand, TexParameter, TexParameterFloat};
use canvas_traits::webgl::{TexParameterInt, WebGLCommand, WebGLError, WebGLMsgSender};
use canvas_traits::webgl::{TexParameterInt, WebGLCommand, WebGLError};
use canvas_traits::webgl::{WebGLResult, WebGLTextureId, webgl_channel};
use dom::bindings::cell::DomRefCell;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
use dom::bindings::codegen::Bindings::WebGLTextureBinding;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::inheritance::Castable;
use dom::bindings::reflector::{DomObject, reflect_dom_object};
use dom::bindings::root::DomRoot;
use dom::webgl_validations::types::{TexImageTarget, TexFormat, TexDataType};
use dom::webglobject::WebGLObject;
use dom::window::Window;
use dom::webglrenderingcontext::WebGLRenderingContext;
use dom_struct::dom_struct;
use std::cell::Cell;
use std::cmp;
@ -45,18 +46,14 @@ pub struct WebGLTexture {
// Store information for min and mag filters
min_filter: Cell<Option<u32>>,
mag_filter: Cell<Option<u32>>,
#[ignore_malloc_size_of = "Defined in ipc-channel"]
renderer: WebGLMsgSender,
/// True if this texture is used for the DOMToTexture feature.
attached_to_dom: Cell<bool>,
}
impl WebGLTexture {
fn new_inherited(renderer: WebGLMsgSender,
id: WebGLTextureId)
-> WebGLTexture {
WebGLTexture {
webgl_object: WebGLObject::new_inherited(),
fn new_inherited(context: &WebGLRenderingContext, id: WebGLTextureId) -> Self {
Self {
webgl_object: WebGLObject::new_inherited(context),
id: id,
target: Cell::new(None),
is_deleted: Cell::new(false),
@ -65,27 +62,22 @@ impl WebGLTexture {
min_filter: Cell::new(None),
mag_filter: Cell::new(None),
image_info_array: DomRefCell::new([ImageInfo::new(); MAX_LEVEL_COUNT * MAX_FACE_COUNT]),
renderer: renderer,
attached_to_dom: Cell::new(false),
}
}
pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
-> Option<DomRoot<WebGLTexture>> {
pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
let (sender, receiver) = webgl_channel().unwrap();
renderer.send(WebGLCommand::CreateTexture(sender)).unwrap();
let result = receiver.recv().unwrap();
result.map(|texture_id| WebGLTexture::new(window, renderer, texture_id))
context.send_command(WebGLCommand::CreateTexture(sender));
receiver.recv().unwrap().map(|id| WebGLTexture::new(context, id))
}
pub fn new(window: &Window,
renderer: WebGLMsgSender,
id: WebGLTextureId)
-> DomRoot<WebGLTexture> {
reflect_dom_object(Box::new(WebGLTexture::new_inherited(renderer, id)),
window,
WebGLTextureBinding::Wrap)
pub fn new(context: &WebGLRenderingContext, id: WebGLTextureId) -> DomRoot<Self> {
reflect_dom_object(
Box::new(WebGLTexture::new_inherited(context, id)),
&*context.global(),
WebGLTextureBinding::Wrap,
)
}
}
@ -116,8 +108,9 @@ impl WebGLTexture {
self.target.set(Some(target));
}
let msg = WebGLCommand::BindTexture(target, Some(self.id));
self.renderer.send(msg).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::BindTexture(target, Some(self.id)));
Ok(())
}
@ -171,7 +164,9 @@ impl WebGLTexture {
return Err(WebGLError::InvalidOperation);
}
self.renderer.send(WebGLCommand::GenerateMipmap(target)).unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::GenerateMipmap(target));
if self.base_mipmap_level + base_image_info.get_max_mimap_levels() == 0 {
return Err(WebGLError::InvalidOperation);
@ -184,11 +179,14 @@ impl WebGLTexture {
pub fn delete(&self) {
if !self.is_deleted.get() {
self.is_deleted.set(true);
let context = self.upcast::<WebGLObject>().context();
// Notify WR to release the frame output when using DOMToTexture feature
if self.attached_to_dom.get() {
let _ = self.renderer.send_dom_to_texture(DOMToTextureCommand::Detach(self.id));
let _ = context.webgl_sender().send_dom_to_texture(
DOMToTextureCommand::Detach(self.id),
);
}
let _ = self.renderer.send(WebGLCommand::DeleteTexture(self.id));
context.send_command(WebGLCommand::DeleteTexture(self.id));
}
}
@ -227,9 +225,9 @@ impl WebGLTexture {
constants::NEAREST_MIPMAP_LINEAR |
constants::LINEAR_MIPMAP_LINEAR => {
self.min_filter.set(Some(int_value as u32));
self.renderer
.send(WebGLCommand::TexParameteri(target, int_param, int_value))
.unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::TexParameteri(target, int_param, int_value));
Ok(())
}
_ => Err(WebGLError::InvalidEnum),
@ -239,9 +237,9 @@ impl WebGLTexture {
match int_value as u32 {
constants::NEAREST | constants::LINEAR => {
self.mag_filter.set(Some(int_value as u32));
self.renderer
.send(WebGLCommand::TexParameteri(target, int_param, int_value))
.unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::TexParameteri(target, int_param, int_value));
Ok(())
}
_ => return Err(WebGLError::InvalidEnum),
@ -252,9 +250,9 @@ impl WebGLTexture {
constants::CLAMP_TO_EDGE |
constants::MIRRORED_REPEAT |
constants::REPEAT => {
self.renderer
.send(WebGLCommand::TexParameteri(target, int_param, int_value))
.unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::TexParameteri(target, int_param, int_value));
Ok(())
}
_ => Err(WebGLError::InvalidEnum),
@ -264,9 +262,9 @@ impl WebGLTexture {
}
TexParameter::Float(float_param @ TexParameterFloat::TextureMaxAnisotropyExt) => {
if float_value >= 1. {
self.renderer
.send(WebGLCommand::TexParameterf(target, float_param, float_value))
.unwrap();
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::TexParameterf(target, float_param, float_value));
Ok(())
} else {
Err(WebGLError::InvalidValue)

21
components/script/dom/webglvertexarrayobjectoes.rs
View file

@ -4,12 +4,11 @@
use canvas_traits::webgl::WebGLVertexArrayId;
use dom::bindings::codegen::Bindings::WebGLVertexArrayObjectOESBinding;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::reflector::{DomObject, reflect_dom_object};
use dom::bindings::root::{DomRoot, MutNullableDom};
use dom::globalscope::GlobalScope;
use dom::webglbuffer::WebGLBuffer;
use dom::webglobject::WebGLObject;
use dom::webglrenderingcontext::VertexAttribs;
use dom::webglrenderingcontext::{VertexAttribs, WebGLRenderingContext};
use dom_struct::dom_struct;
use std::cell::Cell;
@ -24,25 +23,21 @@ pub struct WebGLVertexArrayObjectOES {
}
impl WebGLVertexArrayObjectOES {
fn new_inherited(id: WebGLVertexArrayId, max_vertex_attribs: u32) -> Self {
fn new_inherited(context: &WebGLRenderingContext, id: WebGLVertexArrayId) -> Self {
Self {
webgl_object_: WebGLObject::new_inherited(),
webgl_object_: WebGLObject::new_inherited(context),
id: id,
ever_bound: Cell::new(false),
is_deleted: Cell::new(false),
vertex_attribs: VertexAttribs::new(max_vertex_attribs),
vertex_attribs: VertexAttribs::new(context.limits().max_vertex_attribs),
bound_buffer_element_array: MutNullableDom::new(None),
}
}
pub fn new(
global: &GlobalScope,
id: WebGLVertexArrayId,
max_vertex_attribs: u32,
) -> DomRoot<Self> {
pub fn new(context: &WebGLRenderingContext, id: WebGLVertexArrayId) -> DomRoot<Self> {
reflect_dom_object(
Box::new(WebGLVertexArrayObjectOES::new_inherited(id, max_vertex_attribs)),
global,
Box::new(WebGLVertexArrayObjectOES::new_inherited(context, id)),
&*context.global(),
WebGLVertexArrayObjectOESBinding::Wrap,
)
}

48
tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/context/incorrect-context-object-behaviour.html.ini
View file

@ -1,48 +0,0 @@
[incorrect-context-object-behaviour.html]
bug: https://github.com/servo/servo/issues/21133
type: testharness
[WebGL test #0: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.compileShader(shaderB)]
expected: FAIL
[WebGL test #1: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.linkProgram(programB)]
expected: FAIL
[WebGL test #8: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.shaderSource(shaderB, 'foo')]
expected: FAIL
[WebGL test #9: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.bindAttribLocation(programB, 0, 'foo')]
expected: FAIL
[WebGL test #10: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.bindFramebuffer(contextA.FRAMEBUFFER, frameBufferB)]
expected: FAIL
[WebGL test #11: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.bindRenderbuffer(contextA.RENDERBUFFER, renderBufferB)]
expected: FAIL
[WebGL test #12: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.bindTexture(contextA.TEXTURE_2D, textureB)]
expected: FAIL
[WebGL test #13: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.framebufferRenderbuffer(contextA.FRAMEBUFFER, contextA.DEPTH_ATTACHMENT, contextA.RENDERBUFFER, renderBufferB)]
expected: FAIL
[WebGL test #14: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.framebufferTexture2D(contextA.FRAMEBUFFER, contextA.COLOR_ATTACHMENT0, contextA.TEXTURE_2D, textureB, 0)]
expected: FAIL
[WebGL test #15: getError expected: INVALID_OPERATION. Was INVALID_ENUM : after evaluating: contextA.getProgramParameter(programB, 0)]
expected: FAIL
[WebGL test #16: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.getProgramInfoLog(programB, 0)]
expected: FAIL
[WebGL test #17: getError expected: INVALID_OPERATION. Was INVALID_ENUM : after evaluating: contextA.getShaderParameter(shaderB, 0)]
expected: FAIL
[WebGL test #18: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.getShaderInfoLog(shaderB, 0)]
expected: FAIL
[WebGL test #19: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.getShaderSource(shaderB)]
expected: FAIL
[WebGL test #21: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.getUniformLocation(programB, 'u_modelViewProjMatrix')]
expected: FAIL

5
tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/context/resource-sharing-test.html.ini
View file

@ -1,5 +0,0 @@
[resource-sharing-test.html]
type: testharness
[WebGL test #1: attempt to use a resource from the wrong context should fail with INVALID_OPERATION]
expected: FAIL

15
tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/programs/get-active-test.html.ini
View file

@ -1,15 +0,0 @@
[get-active-test.html]
bug: https://github.com/servo/servo/issues/21133
type: testharness
[WebGL test #31: context2.getActiveAttrib(program, 0) should be null. Was [object WebGLActiveInfo\].]
expected: FAIL
[WebGL test #32: getError expected: INVALID_OPERATION. Was NO_ERROR : ]
expected: FAIL
[WebGL test #33: context2.getActiveUniform(program, 0) should be null. Was [object WebGLActiveInfo\].]
expected: FAIL
[WebGL test #34: getError expected: INVALID_OPERATION. Was NO_ERROR : ]
expected: FAIL