Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-02 21:13:39 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #20317 - gootorov:webgl-getFramebufferAttachmentParameter, r=jdm

Browse source 
Implement WebGL getFrameBufferAttachmentParameter API

<!-- Please describe your changes on the following line: -->
Implementation of `getFramebufferAttachmentParameter` as in WebGL1 specification.

Part of https://github.com/servo/servo/issues/10209.

r? emilio or jdm.

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `__` with appropriate data: -->
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors
- [ ] These changes fix #__ (github issue number if applicable).

<!-- Either: -->
- [x] There are tests for these changes

<!-- Also, please make sure that "Allow edits from maintainers" checkbox is checked, so that we can help you if you get stuck somewhere along the way.-->

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->

<!-- 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/20317)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2018-03-22 12:28:30 -04:00 • committed by GitHub
commit 4aaac61a87
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 338 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

14
components/canvas/webgl_thread.rs
View file

@ -750,6 +750,8 @@ impl WebGLImpl {
Self::active_uniform(ctx.gl(), program_id, index, chan),
WebGLCommand::GetAttribLocation(program_id, name, chan) =>
Self::attrib_location(ctx.gl(), program_id, name, chan),
WebGLCommand::GetFramebufferAttachmentParameter(target, attachment, pname, chan) =>
Self::get_framebuffer_attachment_parameter(ctx.gl(), target, attachment, pname, chan),
WebGLCommand::GetVertexAttrib(index, pname, chan) =>
Self::vertex_attrib(ctx.gl(), index, pname, chan),
WebGLCommand::GetVertexAttribOffset(index, pname, chan) =>
@ -1165,6 +1167,18 @@ impl WebGLImpl {
chan.send(gl.get_string(gl::EXTENSIONS)).unwrap();
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
fn get_framebuffer_attachment_parameter(
gl: &gl::Gl,
target: u32,
attachment: u32,
pname: u32,
chan: WebGLSender<i32>
) {
let parameter = gl.get_framebuffer_attachment_parameter_iv(target, attachment, pname);
chan.send(parameter).unwrap();
}
fn uniform_location(gl: &gl::Gl,
program_id: WebGLProgramId,
name: String,

2
components/canvas_traits/webgl.rs
View file

@ -219,6 +219,7 @@ pub enum WebGLCommand {
GetVertexAttribOffset(u32, u32, WebGLSender<isize>),
GetShaderInfoLog(WebGLShaderId, WebGLSender<String>),
GetProgramInfoLog(WebGLProgramId, WebGLSender<String>),
GetFramebufferAttachmentParameter(u32, u32, u32, WebGLSender<i32>),
PolygonOffset(f32, f32),
RenderbufferStorage(u32, u32, i32, i32),
ReadPixels(i32, i32, i32, i32, u32, u32, WebGLSender<Vec<u8>>),
@ -490,6 +491,7 @@ impl fmt::Debug for WebGLCommand {
GetProgramInfoLog(..) => "GetProgramInfoLog",
GetVertexAttrib(..) => "GetVertexAttrib",
GetVertexAttribOffset(..) => "GetVertexAttribOffset",
GetFramebufferAttachmentParameter(..) => "GetFramebufferAttachmentParameter",
PolygonOffset(..) => "PolygonOffset",
ReadPixels(..) => "ReadPixels",
RenderbufferStorage(..) => "RenderbufferStorage",

12
components/script/dom/webgl2renderingcontext.rs
View file

@ -142,6 +142,18 @@ impl WebGL2RenderingContextMethods for WebGL2RenderingContext {
self.base.GetExtension(cx, name)
}
#[allow(unsafe_code)]
/// https://www.khronos.org/registry/webgl/specs/latest/2.0/#3.7.4
unsafe fn GetFramebufferAttachmentParameter(
&self,
cx: *mut JSContext,
target: u32,
attachment: u32,
pname: u32
) -> JSVal {
self.base.GetFramebufferAttachmentParameter(cx, target, attachment, pname)
}
/// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.3
fn ActiveTexture(&self, texture: u32) {
self.base.ActiveTexture(texture)

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

@ -25,6 +25,12 @@ enum WebGLFramebufferAttachment {
Texture { texture: Dom<WebGLTexture>, level: i32 },
}
#[derive(Clone, JSTraceable, MallocSizeOf)]
pub enum WebGLFramebufferAttachmentRoot {
Renderbuffer(DomRoot<WebGLRenderbuffer>),
Texture(DomRoot<WebGLTexture>),
}
#[dom_struct]
pub struct WebGLFramebuffer {
webgl_object: WebGLObject,
@ -213,6 +219,25 @@ impl WebGLFramebuffer {
Ok(())
}
pub fn attachment(&self, attachment: u32) -> Option<WebGLFramebufferAttachmentRoot> {
let binding = match attachment {
constants::COLOR_ATTACHMENT0 => &self.color,
constants::DEPTH_ATTACHMENT => &self.depth,
constants::STENCIL_ATTACHMENT => &self.stencil,
constants::DEPTH_STENCIL_ATTACHMENT => &self.depthstencil,
_ => return None,
};
binding.borrow().as_ref().map(|bin| {
match bin {
&WebGLFramebufferAttachment::Renderbuffer(ref rb) =>
WebGLFramebufferAttachmentRoot::Renderbuffer(DomRoot::from_ref(&rb)),
&WebGLFramebufferAttachment::Texture { ref texture, .. } =>
WebGLFramebufferAttachmentRoot::Texture(DomRoot::from_ref(&texture)),
}
})
}
pub fn texture2d(&self, attachment: u32, textarget: u32, texture: Option<&WebGLTexture>,
level: i32) -> WebGLResult<()> {
let binding = match attachment {

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

@ -10,6 +10,7 @@ use canvas_traits::webgl::DOMToTextureCommand;
use canvas_traits::webgl::WebGLError::*;
use canvas_traits::webgl::webgl_channel;
use dom::bindings::cell::DomRefCell;
use dom::bindings::codegen::Bindings::WebGL2RenderingContextBinding::WebGL2RenderingContextConstants as WebGL2Constants;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::{self, WebGLContextAttributes};
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextMethods;
@ -33,7 +34,7 @@ use dom::webgl_validations::types::{TexDataType, TexFormat, TexImageTarget};
use dom::webglactiveinfo::WebGLActiveInfo;
use dom::webglbuffer::WebGLBuffer;
use dom::webglcontextevent::WebGLContextEvent;
use dom::webglframebuffer::WebGLFramebuffer;
use dom::webglframebuffer::{WebGLFramebuffer, WebGLFramebufferAttachmentRoot};
use dom::webglprogram::WebGLProgram;
use dom::webglrenderbuffer::WebGLRenderbuffer;
use dom::webglshader::WebGLShader;
@ -1554,6 +1555,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 target == WebGL2Constants::READ_FRAMEBUFFER {
return self.webgl_error(InvalidEnum);
}
if target != constants::FRAMEBUFFER {
return self.webgl_error(InvalidOperation);
}
@ -2297,6 +2302,93 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
}
}
#[allow(unsafe_code)]
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
unsafe fn GetFramebufferAttachmentParameter(
&self,
cx: *mut JSContext,
target: u32,
attachment: u32,
pname: u32
) -> JSVal {
// Check if currently bound framebuffer is non-zero as per spec.
if self.bound_framebuffer.get().is_none() {
self.webgl_error(InvalidOperation);
return NullValue();
}
// Note: commented out stuff is for the WebGL2 standard.
let target_matches = match target {
// constants::READ_FRAMEBUFFER |
// constants::DRAW_FRAMEBUFFER => true,
constants::FRAMEBUFFER => true,
_ => false
};
let attachment_matches = match attachment {
// constants::MAX_COLOR_ATTACHMENTS ... gl::COLOR_ATTACHMENT0 |
// constants::BACK |
constants::COLOR_ATTACHMENT0 |
constants::DEPTH_STENCIL_ATTACHMENT |
constants::DEPTH_ATTACHMENT |
constants::STENCIL_ATTACHMENT => true,
_ => false,
};
let pname_matches = match pname {
// constants::FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE |
// constants::FRAMEBUFFER_ATTACHMENT_BLUE_SIZE |
// constants::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING |
// constants::FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE |
// constants::FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE |
// constants::FRAMEBUFFER_ATTACHMENT_GREEN_SIZE |
// constants::FRAMEBUFFER_ATTACHMENT_RED_SIZE |
// constants::FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE |
// constants::FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER |
constants::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME |
constants::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE |
constants::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE |
constants::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL => true,
_ => false
};
if !target_matches || !attachment_matches || !pname_matches {
self.webgl_error(InvalidEnum);
return NullValue();
}
// From the GLES2 spec:
//
// If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is NONE,
// then querying any other pname will generate INVALID_ENUM.
//
// otherwise, return `WebGLRenderbuffer` or `WebGLTexture` dom object
if pname == constants::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME {
// if fb is None, an INVALID_OPERATION is returned
// at the beggining of the function, so `.unwrap()` will never panic
let fb = self.bound_framebuffer.get().unwrap();
if let Some(webgl_attachment) = fb.attachment(attachment) {
match webgl_attachment {
WebGLFramebufferAttachmentRoot::Renderbuffer(rb) => {
rooted!(in(cx) let mut rval = NullValue());
rb.to_jsval(cx, rval.handle_mut());
return rval.get();
},
WebGLFramebufferAttachmentRoot::Texture(texture) => {
rooted!(in(cx) let mut rval = NullValue());
texture.to_jsval(cx, rval.handle_mut());
return rval.get();
},
}
}
self.webgl_error(InvalidEnum);
return NullValue();
}
let (sender, receiver) = webgl_channel().unwrap();
self.send_command(WebGLCommand::GetFramebufferAttachmentParameter(target, attachment, pname, sender));
Int32Value(receiver.recv().unwrap())
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn GetProgramInfoLog(&self, program: Option<&WebGLProgram>) -> Option<DOMString> {
if let Some(program) = program {

4
components/script/dom/webidls/WebGLRenderingContext.webidl
View file

@ -589,8 +589,8 @@ interface WebGLRenderingContextBase
[WebGLHandlesContextLoss] GLenum getError();
//any getFramebufferAttachmentParameter(GLenum target, GLenum attachment,
// GLenum pname);
any getFramebufferAttachmentParameter(GLenum target, GLenum attachment,
GLenum pname);
any getProgramParameter(WebGLProgram? program, GLenum pname);
DOMString? getProgramInfoLog(WebGLProgram? program);
//any getRenderbufferParameter(GLenum target, GLenum pname);