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

WebGL2: support TexImage3D (#37718)

Browse source 
Add TexImage3D method to WebGL2RenderingContext

Testing: conformance2 should pass. Also it should get
http://webglsamples.org/WebGL2Samples/#texture_2d_array and
http://webglsamples.org/WebGL2Samples/#texture_3d running.
Fixes: #26511

Now Servo can run texture_2d_array and texture_3d samples!

![圖片](https://github.com/user-attachments/assets/41b87563-08b8-4db3-b503-12f3a61dbed7)

![圖片](https://github.com/user-attachments/assets/3c62a4de-35ea-488d-b2e5-00e3aed52090)

And it can now run three.js too!

![圖片](https://github.com/user-attachments/assets/d880aa92-a154-4895-aa06-b7919d1fc869)

---------

Signed-off-by: Wu Yu Wei <yuweiwu@pm.me>
This commit is contained in:
Ngo Iok Ui (Wu Yu Wei) 2025-07-09 23:22:03 +09:00 • committed by GitHub
parent 4499fdeb2b
commit 34c31ee418
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
43 changed files with 1341 additions and 980 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -11,8 +11,8 @@ use std::rc::Rc;
use bitflags::bitflags;
use canvas_traits::webgl::WebGLError::*;
use canvas_traits::webgl::{
GLContextAttributes, InternalFormatParameter, WebGLCommand, WebGLContextId, WebGLResult,
WebGLVersion, webgl_channel,
AlphaTreatment, GLContextAttributes, InternalFormatParameter, TexDataType, TexFormat,
WebGLCommand, WebGLContextId, WebGLResult, WebGLVersion, YAxisTreatment, webgl_channel,
};
use dom_struct::dom_struct;
use euclid::default::{Point2D, Rect, Size2D};
@ -27,6 +27,7 @@ use servo_config::pref;
use url::Host;
use webrender_api::ImageKey;
use super::webgl_validations::types::TexImageTarget;
use crate::canvas_context::CanvasContext;
use crate::dom::bindings::codegen::Bindings::WebGL2RenderingContextBinding::{
WebGL2RenderingContextConstants as constants, WebGL2RenderingContextMethods,
@ -51,6 +52,7 @@ use crate::dom::webgl_validations::WebGLValidator;
use crate::dom::webgl_validations::tex_image_2d::{
TexImage2DValidator, TexImage2DValidatorResult, TexStorageValidator, TexStorageValidatorResult,
};
use crate::dom::webgl_validations::tex_image_3d::{TexImage3DValidator, TexImage3DValidatorResult};
use crate::dom::webglactiveinfo::WebGLActiveInfo;
use crate::dom::webglbuffer::WebGLBuffer;
use crate::dom::webglframebuffer::{WebGLFramebuffer, WebGLFramebufferAttachmentRoot};
@ -899,6 +901,66 @@ impl WebGL2RenderingContext {
texture.storage(target, levels, internal_format, width, height, depth)
);
}
#[allow(clippy::too_many_arguments)]
fn tex_image_3d(
&self,
texture: &WebGLTexture,
target: TexImageTarget,
data_type: TexDataType,
internal_format: TexFormat,
format: TexFormat,
level: u32,
width: u32,
height: u32,
depth: u32,
_border: u32,
unpacking_alignment: u32,
data: TexPixels,
) {
handle_potential_webgl_error!(
self.base,
texture.initialize(
target,
width,
height,
depth,
internal_format,
level,
Some(data_type)
)
);
let internal_format = self
.base
.extension_manager()
.get_effective_tex_internal_format(internal_format, data_type.as_gl_constant());
let effective_data_type = self
.base
.extension_manager()
.effective_type(data_type.as_gl_constant());
self.base.send_command(WebGLCommand::TexImage3D {
target: target.as_gl_constant(),
level,
internal_format,
size: data.size(),
depth,
format,
data_type,
effective_data_type,
unpacking_alignment,
alpha_treatment: data.alpha_treatment(),
y_axis_treatment: data.y_axis_treatment(),
pixel_format: data.pixel_format(),
data: data.into_shared_memory().into(),
});
// TODO: Hint/tex_parameter
if let Some(fb) = self.base.bound_draw_framebuffer() {
fb.invalidate_texture(texture);
}
}
}
impl CanvasContext for WebGL2RenderingContext {
@ -2344,6 +2406,8 @@ impl WebGL2RenderingContextMethods<crate::DomTypeHolder> for WebGL2RenderingCont
constants::BOOL |
constants::UNSIGNED_INT |
constants::SAMPLER_2D |
constants::SAMPLER_2D_ARRAY |
constants::SAMPLER_3D |
constants::SAMPLER_CUBE => {},
_ => return Err(InvalidOperation),
}
@ -2992,6 +3056,136 @@ impl WebGL2RenderingContextMethods<crate::DomTypeHolder> for WebGL2RenderingCont
self.base.Viewport(x, y, width, height)
}
/// <https://www.khronos.org/registry/webgl/specs/latest/2.0/#3.7.6>
///
/// Allocates and initializes the specified mipmap level of a three-dimensional or
/// two-dimensional array texture.
#[allow(unsafe_code)]
fn TexImage3D(
&self,
target: u32,
level: i32,
internal_format: i32,
width: i32,
height: i32,
depth: i32,
border: i32,
format: u32,
type_: u32,
src_data: CustomAutoRooterGuard<Option<ArrayBufferView>>,
) -> Fallible<()> {
// If a WebGLBuffer is bound to the PIXEL_UNPACK_BUFFER target,
// generates an INVALID_OPERATION error.
if self.bound_pixel_unpack_buffer.get().is_some() {
self.base.webgl_error(InvalidOperation);
return Ok(());
}
// If type is specified as FLOAT_32_UNSIGNED_INT_24_8_REV, srcData must be null;
// otherwise, generates an INVALID_OPERATION error.
if type_ == constants::FLOAT_32_UNSIGNED_INT_24_8_REV && src_data.is_some() {
self.base.webgl_error(InvalidOperation);
return Ok(());
}
if border != 0 {
self.base.webgl_error(InvalidValue);
return Ok(());
}
let Ok(TexImage3DValidatorResult {
width,
height,
depth,
level,
border,
texture,
target,
internal_format,
format,
data_type,
}) = TexImage3DValidator::new(
&self.base,
target,
level,
internal_format as u32,
width,
height,
depth,
border,
format,
type_,
&src_data,
)
.validate()
else {
return Ok(());
};
// TODO: If pixel store parameter constraints are not met, generates an INVALID_OPERATION error.
// If srcData is null, a buffer of sufficient size initialized to 0 is passed.
let unpacking_alignment = self.base.texture_unpacking_alignment();
let buff = match *src_data {
Some(ref data) => IpcSharedMemory::from_bytes(unsafe { data.as_slice() }),
None => {
let element_size = data_type.element_size();
let components = format.components();
let components_per_element = format.components();
// FIXME: This is copied from tex_image_2d which is apparently incorrect
// NOTE: width and height are positive or zero due to validate()
let expected_byte_len = if height == 0 {
0
} else {
// We need to be careful here to not count unpack
// alignment at the end of the image, otherwise (for
// example) passing a single byte for uploading a 1x1
// GL_ALPHA/GL_UNSIGNED_BYTE texture would throw an error.
let cpp = element_size * components / components_per_element;
let stride =
(width * cpp + unpacking_alignment - 1) & !(unpacking_alignment - 1);
stride * (height - 1) + width * cpp
};
IpcSharedMemory::from_bytes(&vec![0u8; expected_byte_len as usize])
},
};
let (alpha_treatment, y_axis_treatment) =
self.base.get_current_unpack_state(Alpha::NotPremultiplied);
// If UNPACK_FLIP_Y_WEBGL or UNPACK_PREMULTIPLY_ALPHA_WEBGL is set to true, texImage3D and texSubImage3D
// generate an INVALID_OPERATION error if they upload data from a PIXEL_UNPACK_BUFFER or a non-null client
// side ArrayBufferView.
if let (Some(AlphaTreatment::Premultiply), YAxisTreatment::Flipped) =
(alpha_treatment, y_axis_treatment)
{
if src_data.is_some() {
self.base.webgl_error(InvalidOperation);
return Ok(());
}
}
let tex_source = TexPixels::from_array(
buff,
Size2D::new(width, height),
alpha_treatment,
y_axis_treatment,
);
self.tex_image_3d(
&texture,
target,
data_type,
internal_format,
format,
level,
width,
height,
depth,
border,
unpacking_alignment,
tex_source,
);
Ok(())
}
/// <https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8>
fn TexImage2D(
&self,

1
components/script/dom/webgl_validations/mod.rs
View file

@ -10,4 +10,5 @@ pub(crate) trait WebGLValidator {
}
pub(crate) mod tex_image_2d;
pub(crate) mod tex_image_3d;
pub(crate) mod types;

311
components/script/dom/webgl_validations/tex_image_3d.rs Normal file
View file

@ -0,0 +1,311 @@
/* 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 https://mozilla.org/MPL/2.0/. */
use canvas_traits::webgl::WebGLError::*;
use canvas_traits::webgl::{TexDataType, TexFormat};
use js::jsapi::Type;
use js::typedarray::ArrayBufferView;
use super::WebGLValidator;
use super::tex_image_2d::TexImageValidationError;
use super::types::TexImageTarget;
use crate::dom::bindings::root::DomRoot;
use crate::dom::webglrenderingcontext::WebGLRenderingContext;
use crate::dom::webgltexture::WebGLTexture;
fn log2(n: u32) -> u32 {
31 - n.leading_zeros()
}
pub(crate) struct CommonTexImage3DValidator<'a> {
context: &'a WebGLRenderingContext,
target: u32,
level: i32,
internal_format: u32,
width: i32,
height: i32,
depth: i32,
border: i32,
}
pub(crate) struct CommonTexImage3DValidatorResult {
pub(crate) texture: DomRoot<WebGLTexture>,
pub(crate) target: TexImageTarget,
pub(crate) level: u32,
pub(crate) internal_format: TexFormat,
pub(crate) width: u32,
pub(crate) height: u32,
pub(crate) depth: u32,
pub(crate) border: u32,
}
impl WebGLValidator for CommonTexImage3DValidator<'_> {
type Error = TexImageValidationError;
type ValidatedOutput = CommonTexImage3DValidatorResult;
fn validate(self) -> Result<Self::ValidatedOutput, TexImageValidationError> {
// GL_INVALID_ENUM is generated if target is not GL_TEXTURE_3D or GL_TEXTURE_2D_ARRAY.
let target = match TexImageTarget::from_gl_constant(self.target) {
Some(target) if target.dimensions() == 3 => target,
_ => {
self.context.webgl_error(InvalidEnum);
return Err(TexImageValidationError::InvalidTextureTarget(self.target));
},
};
let texture = self
.context
.textures()
.active_texture_for_image_target(target);
let limits = self.context.limits();
let max_size = limits.max_3d_tex_size;
// If an attempt is made to call this function with no WebGLTexture
// bound, an INVALID_OPERATION error is generated.
let texture = match texture {
Some(texture) => texture,
None => {
self.context.webgl_error(InvalidOperation);
return Err(TexImageValidationError::TextureTargetNotBound(self.target));
},
};
// GL_INVALID_ENUM is generated if internal_format is not an accepted
// format.
let internal_format = match TexFormat::from_gl_constant(self.internal_format) {
Some(format)
if format.required_webgl_version() <= self.context.webgl_version() &&
format.usable_as_internal() =>
{
format
},
_ => {
self.context.webgl_error(InvalidEnum);
return Err(TexImageValidationError::InvalidTextureFormat);
},
};
// GL_INVALID_VALUE is generated if width, height, or depth is less than 0 or greater than
// GL_MAX_3D_TEXTURE_SIZE.
if self.width < 0 || self.height < 0 || self.depth < 0 {
self.context.webgl_error(InvalidValue);
return Err(TexImageValidationError::NegativeDimension);
}
let width = self.width as u32;
let height = self.height as u32;
let depth = self.depth as u32;
let level = self.level as u32;
if width > max_size || height > max_size || level > max_size {
self.context.webgl_error(InvalidValue);
return Err(TexImageValidationError::TextureTooBig);
}
// GL_INVALID_VALUE may be generated if level is greater than log2(max),
// where max is the returned value of GL_MAX_3D_TEXTURE_SIZE.
if self.level < 0 {
self.context.webgl_error(InvalidValue);
return Err(TexImageValidationError::NegativeLevel);
}
if level > log2(max_size) {
self.context.webgl_error(InvalidValue);
return Err(TexImageValidationError::LevelTooHigh);
}
// GL_INVALID_VALUE is generated if border is not 0 or 1.
if !(self.border == 0 || self.border == 1) {
self.context.webgl_error(InvalidValue);
return Err(TexImageValidationError::InvalidBorder);
}
Ok(CommonTexImage3DValidatorResult {
texture,
target,
level,
internal_format,
width,
height,
depth,
border: self.border as u32,
})
}
}
impl<'a> CommonTexImage3DValidator<'a> {
#[allow(clippy::too_many_arguments)]
pub(crate) fn new(
context: &'a WebGLRenderingContext,
target: u32,
level: i32,
internal_format: u32,
width: i32,
height: i32,
depth: i32,
border: i32,
) -> Self {
CommonTexImage3DValidator {
context,
target,
level,
internal_format,
width,
height,
depth,
border,
}
}
}
pub(crate) struct TexImage3DValidator<'a> {
common_validator: CommonTexImage3DValidator<'a>,
format: u32,
data_type: u32,
data: &'a Option<ArrayBufferView>,
}
impl<'a> TexImage3DValidator<'a> {
/// TODO: Move data validation logic here.
#[allow(clippy::too_many_arguments)]
pub(crate) fn new(
context: &'a WebGLRenderingContext,
target: u32,
level: i32,
internal_format: u32,
width: i32,
height: i32,
depth: i32,
border: i32,
format: u32,
data_type: u32,
data: &'a Option<ArrayBufferView>,
) -> Self {
TexImage3DValidator {
common_validator: CommonTexImage3DValidator::new(
context,
target,
level,
internal_format,
width,
height,
depth,
border,
),
format,
data_type,
data,
}
}
}
/// The validated result of a TexImage2DValidator-validated call.
pub(crate) struct TexImage3DValidatorResult {
/// NB: width, height and level are already unsigned after validation.
pub(crate) width: u32,
pub(crate) height: u32,
pub(crate) depth: u32,
pub(crate) level: u32,
pub(crate) border: u32,
pub(crate) texture: DomRoot<WebGLTexture>,
pub(crate) target: TexImageTarget,
pub(crate) internal_format: TexFormat,
pub(crate) format: TexFormat,
pub(crate) data_type: TexDataType,
}
/// TexImage3d validator as per
/// <https://www.khronos.org/opengles/sdk/docs/man/xhtml/glTexImage3D.xml>
impl WebGLValidator for TexImage3DValidator<'_> {
type ValidatedOutput = TexImage3DValidatorResult;
type Error = TexImageValidationError;
fn validate(self) -> Result<Self::ValidatedOutput, TexImageValidationError> {
let context = self.common_validator.context;
let CommonTexImage3DValidatorResult {
texture,
target,
level,
internal_format,
width,
height,
depth,
border,
} = self.common_validator.validate()?;
// GL_INVALID_ENUM is generated if format is not an accepted format constant.
// Format constants other than GL_STENCIL_INDEX and GL_DEPTH_COMPONENT are accepted.
let data_type = match TexDataType::from_gl_constant(self.data_type) {
Some(data_type) if data_type.required_webgl_version() <= context.webgl_version() => {
data_type
},
_ => {
context.webgl_error(InvalidEnum);
return Err(TexImageValidationError::InvalidDataType);
},
};
let format = match TexFormat::from_gl_constant(self.format) {
Some(format) if format.required_webgl_version() <= context.webgl_version() => format,
_ => {
context.webgl_error(InvalidEnum);
return Err(TexImageValidationError::InvalidTextureFormat);
},
};
// GL_INVALID_OPERATION is generated if format does not match
// internal_format.
if format != internal_format.to_unsized() {
context.webgl_error(InvalidOperation);
return Err(TexImageValidationError::TextureFormatMismatch);
}
if !internal_format.compatible_data_types().contains(&data_type) {
context.webgl_error(InvalidOperation);
return Err(TexImageValidationError::TextureFormatMismatch);
}
// GL_INVALID_OPERATION is generated if target is GL_TEXTURE_3D and
// format is GL_DEPTH_COMPONENT, or GL_DEPTH_STENCIL.
if target == TexImageTarget::Texture3D &&
(format == TexFormat::DepthComponent || format == TexFormat::DepthStencil)
{
context.webgl_error(InvalidOperation);
return Err(TexImageValidationError::InvalidTypeForFormat);
}
// If srcData is non-null, the type of srcData must match the type according to
// the above table; otherwise, generate an INVALID_OPERATION error.
let element_size = data_type.element_size();
let received_size = match self.data {
Some(buf) => match buf.get_array_type() {
Type::Int8 => 1,
Type::Uint8 => 1,
Type::Int16 => 2,
Type::Uint16 => 2,
Type::Int32 => 4,
Type::Uint32 => 4,
Type::Float32 => 4,
_ => {
context.webgl_error(InvalidOperation);
return Err(TexImageValidationError::InvalidTypeForFormat);
},
},
None => element_size,
};
if received_size != element_size {
context.webgl_error(InvalidOperation);
return Err(TexImageValidationError::InvalidTypeForFormat);
}
Ok(TexImage3DValidatorResult {
width,
height,
depth,
level,
border,
texture,
target,
internal_format,
format,
data_type,
})
}
}

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

@ -143,7 +143,7 @@ pub(crate) unsafe fn uniform_typed<T>(
/// Set of bitflags for texture unpacking (texImage2d, etc...)
#[derive(Clone, Copy, JSTraceable, MallocSizeOf)]
struct TextureUnpacking(u8);
pub(crate) struct TextureUnpacking(u8);
bitflags! {
impl TextureUnpacking: u8 {
@ -327,6 +327,10 @@ impl WebGLRenderingContext {
self.texture_unpacking_alignment.get()
}
pub(crate) fn bound_draw_framebuffer(&self) -> Option<DomRoot<WebGLFramebuffer>> {
self.bound_draw_framebuffer.get()
}
pub(crate) fn current_vao(&self) -> DomRoot<WebGLVertexArrayObjectOES> {
self.current_vao.or_init(|| {
DomRoot::from_ref(
@ -1680,6 +1684,8 @@ impl WebGLRenderingContext {
constants::BOOL |
constants::INT |
constants::SAMPLER_2D |
WebGL2RenderingContextConstants::SAMPLER_2D_ARRAY |
WebGL2RenderingContextConstants::SAMPLER_3D |
constants::SAMPLER_CUBE => {},
_ => return Err(InvalidOperation),
}
@ -1687,7 +1693,10 @@ impl WebGLRenderingContext {
let val = self.uniform_vec_section_int(val, src_offset, src_length, 1, location)?;
match location.type_() {
constants::SAMPLER_2D | constants::SAMPLER_CUBE => {
constants::SAMPLER_2D |
constants::SAMPLER_CUBE |
WebGL2RenderingContextConstants::SAMPLER_2D_ARRAY |
WebGL2RenderingContextConstants::SAMPLER_3D => {
for &v in val
.iter()
.take(cmp::min(location.size().unwrap_or(1) as usize, val.len()))
@ -2149,6 +2158,30 @@ impl WebGLRenderingContextMethods<crate::DomTypeHolder> for WebGLRenderingContex
texture.to_jsval(*cx, retval);
return;
},
WebGL2RenderingContextConstants::TEXTURE_BINDING_2D_ARRAY => unsafe {
let texture = self
.textures
.active_texture_slot(
WebGL2RenderingContextConstants::TEXTURE_2D_ARRAY,
self.webgl_version(),
)
.unwrap()
.get();
texture.to_jsval(*cx, retval);
return;
},
WebGL2RenderingContextConstants::TEXTURE_BINDING_3D => unsafe {
let texture = self
.textures
.active_texture_slot(
WebGL2RenderingContextConstants::TEXTURE_3D,
self.webgl_version(),
)
.unwrap()
.get();
texture.to_jsval(*cx, retval);
return;
},
constants::TEXTURE_BINDING_CUBE_MAP => unsafe {
let texture = self
.textures
@ -4036,7 +4069,10 @@ impl WebGLRenderingContextMethods<crate::DomTypeHolder> for WebGLRenderingContex
self.with_location(location, |location| {
match location.type_() {
constants::BOOL | constants::INT => {},
constants::SAMPLER_2D | constants::SAMPLER_CUBE => {
constants::SAMPLER_2D |
WebGL2RenderingContextConstants::SAMPLER_3D |
WebGL2RenderingContextConstants::SAMPLER_2D_ARRAY |
constants::SAMPLER_CUBE => {
if val < 0 || val as u32 >= self.limits.max_combined_texture_image_units {
return Err(InvalidValue);
}
@ -4237,7 +4273,11 @@ impl WebGLRenderingContextMethods<crate::DomTypeHolder> for WebGLRenderingContex
constants::BOOL_VEC4 => unsafe {
uniform_get(triple, WebGLCommand::GetUniformBool4).to_jsval(*cx, rval);
},
constants::INT | constants::SAMPLER_2D | constants::SAMPLER_CUBE => {
constants::INT |
constants::SAMPLER_2D |
constants::SAMPLER_CUBE |
WebGL2RenderingContextConstants::SAMPLER_2D_ARRAY |
WebGL2RenderingContextConstants::SAMPLER_3D => {
rval.set(Int32Value(uniform_get(triple, WebGLCommand::GetUniformInt)))
},
constants::INT_VEC2 => unsafe {
@ -5122,6 +5162,22 @@ impl TexPixels {
pub(crate) fn size(&self) -> Size2D<u32> {
self.size
}
pub(crate) fn pixel_format(&self) -> Option<PixelFormat> {
self.pixel_format
}
pub(crate) fn alpha_treatment(&self) -> Option<AlphaTreatment> {
self.alpha_treatment
}
pub(crate) fn y_axis_treatment(&self) -> YAxisTreatment {
self.y_axis_treatment
}
pub(crate) fn into_shared_memory(self) -> IpcSharedMemory {
self.data
}
}
pub(crate) enum TexSource {

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

@ -11,7 +11,7 @@ use std::cmp;
use canvas_traits::webgl::{
TexDataType, TexFormat, TexParameter, TexParameterBool, TexParameterInt, WebGLCommand,
WebGLError, WebGLResult, WebGLTextureId, webgl_channel,
WebGLError, WebGLResult, WebGLTextureId, WebGLVersion, webgl_channel,
};
use dom_struct::dom_struct;
@ -158,7 +158,7 @@ impl WebGLTexture {
} else {
// This is the first time binding
let face_count = match target {
constants::TEXTURE_2D => 1,
constants::TEXTURE_2D | constants::TEXTURE_2D_ARRAY | constants::TEXTURE_3D => 1,
constants::TEXTURE_CUBE_MAP => 6,
_ => return Err(WebGLError::InvalidEnum),
};
@ -314,16 +314,60 @@ impl WebGLTexture {
TexParameterValue::Bool(_) => unreachable!("no settable tex params should be booleans"),
};
let context = self.upcast::<WebGLObject>().context();
let is_webgl2 = context.webgl_version() == WebGLVersion::WebGL2;
let update_filter = |filter: &Cell<u32>| {
if filter.get() == int_value as u32 {
return Ok(());
}
filter.set(int_value as u32);
context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
Ok(())
};
if is_webgl2 {
match param {
constants::TEXTURE_BASE_LEVEL | constants::TEXTURE_MAX_LEVEL => {
context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
return Ok(());
},
constants::TEXTURE_COMPARE_FUNC => match int_value as u32 {
constants::LEQUAL |
constants::GEQUAL |
constants::LESS |
constants::GREATER |
constants::EQUAL |
constants::NOTEQUAL |
constants::ALWAYS |
constants::NEVER => {
context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
return Ok(());
},
_ => return Err(WebGLError::InvalidEnum),
},
constants::TEXTURE_COMPARE_MODE => match int_value as u32 {
constants::COMPARE_REF_TO_TEXTURE | constants::NONE => {
context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
return Ok(());
},
_ => return Err(WebGLError::InvalidEnum),
},
constants::TEXTURE_MAX_LOD | constants::TEXTURE_MIN_LOD => {
context.send_command(WebGLCommand::TexParameterf(target, param, float_value));
return Ok(());
},
constants::TEXTURE_WRAP_R => match int_value as u32 {
constants::CLAMP_TO_EDGE | constants::MIRRORED_REPEAT | constants::REPEAT => {
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::TexParameteri(target, param, int_value));
Ok(())
};
return Ok(());
},
_ => return Err(WebGLError::InvalidEnum),
},
_ => {},
}
}
match param {
constants::TEXTURE_MIN_FILTER => match int_value as u32 {
constants::NEAREST |
@ -340,9 +384,7 @@ impl WebGLTexture {
},
constants::TEXTURE_WRAP_S | constants::TEXTURE_WRAP_T => match int_value as u32 {
constants::CLAMP_TO_EDGE | constants::MIRRORED_REPEAT | constants::REPEAT => {
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::TexParameteri(target, param, int_value));
context.send_command(WebGLCommand::TexParameteri(target, param, int_value));
Ok(())
},
_ => Err(WebGLError::InvalidEnum),
@ -352,9 +394,7 @@ impl WebGLTexture {
if float_value < 1. || !float_value.is_normal() {
return Err(WebGLError::InvalidValue);
}
self.upcast::<WebGLObject>()
.context()
.send_command(WebGLCommand::TexParameterf(target, param, float_value));
context.send_command(WebGLCommand::TexParameterf(target, param, float_value));
Ok(())
},
_ => Err(WebGLError::InvalidEnum),

6
components/script_bindings/webidls/WebGL2RenderingContext.webidl
View file

@ -322,9 +322,9 @@ interface mixin WebGL2RenderingContextBase
//void texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
// GLsizei depth, GLint border, GLenum format, GLenum type,
// TexImageSource source); // May throw DOMException
//[Throws]
//void texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
// GLsizei depth, GLint border, GLenum format, GLenum type, [AllowShared] ArrayBufferView? srcData);
[Throws]
undefined texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
GLsizei depth, GLint border, GLenum format, GLenum type, /*[AllowShared]*/ ArrayBufferView? srcData);
//[Throws]
//void texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
// GLsizei depth, GLint border, GLenum format, GLenum type, [AllowShared] ArrayBufferView srcData,

17
components/shared/canvas/webgl.rs
View file

@ -364,6 +364,22 @@ pub enum WebGLCommand {
VertexAttribPointer(u32, i32, u32, bool, i32, u32),
VertexAttribPointer2f(u32, i32, bool, i32, u32),
SetViewport(i32, i32, i32, i32),
TexImage3D {
target: u32,
level: u32,
internal_format: TexFormat,
size: Size2D<u32>,
depth: u32,
format: TexFormat,
data_type: TexDataType,
// FIXME: This should be computed on the WebGL thread.
effective_data_type: u32,
unpacking_alignment: u32,
alpha_treatment: Option<AlphaTreatment>,
y_axis_treatment: YAxisTreatment,
pixel_format: Option<PixelFormat>,
data: TruncatedDebug<IpcSharedMemory>,
},
TexImage2D {
target: u32,
level: u32,
@ -1437,6 +1453,7 @@ pub struct GLContextAttributes {
pub struct GLLimits {
pub max_vertex_attribs: u32,
pub max_tex_size: u32,
pub max_3d_tex_size: u32,
pub max_cube_map_tex_size: u32,
pub max_combined_texture_image_units: u32,
pub max_fragment_uniform_vectors: u32,

2
components/webgl/webgl_limits.rs
View file

@ -14,6 +14,7 @@ impl GLLimitsDetect for GLLimits {
fn detect(gl: &Gl, webgl_version: WebGLVersion) -> GLLimits {
let max_vertex_attribs = gl.get_integer(gl::MAX_VERTEX_ATTRIBS);
let max_tex_size = gl.get_integer(gl::MAX_TEXTURE_SIZE);
let max_3d_tex_size = gl.get_integer(gl::MAX_3D_TEXTURE_SIZE);
let max_cube_map_tex_size = gl.get_integer(gl::MAX_CUBE_MAP_TEXTURE_SIZE);
let max_combined_texture_image_units = gl.get_integer(gl::MAX_COMBINED_TEXTURE_IMAGE_UNITS);
let max_renderbuffer_size = gl.get_integer(gl::MAX_RENDERBUFFER_SIZE);
@ -160,6 +161,7 @@ impl GLLimitsDetect for GLLimits {
GLLimits {
max_vertex_attribs,
max_tex_size,
max_3d_tex_size,
max_cube_map_tex_size,
max_combined_texture_image_units,
max_fragment_uniform_vectors,

42
components/webgl/webgl_thread.rs
View file

@ -1582,6 +1582,48 @@ impl WebGLImpl {
WebGLCommand::SetViewport(x, y, width, height) => unsafe {
gl.viewport(x, y, width, height)
},
WebGLCommand::TexImage3D {
target,
level,
internal_format,
size,
depth,
format,
data_type,
effective_data_type,
unpacking_alignment,
alpha_treatment,
y_axis_treatment,
pixel_format,
ref data,
} => {
let pixels = prepare_pixels(
internal_format,
data_type,
size,
unpacking_alignment,
alpha_treatment,
y_axis_treatment,
pixel_format,
Cow::Borrowed(data),
);
unsafe {
gl.pixel_store_i32(gl::UNPACK_ALIGNMENT, unpacking_alignment as i32);
gl.tex_image_3d(
target,
level as i32,
internal_format.as_gl_constant() as i32,
size.width as i32,
size.height as i32,
depth as i32,
0,
format.as_gl_constant(),
effective_data_type,
PixelUnpackData::Slice(Some(&pixels)),
);
}
},
WebGLCommand::TexImage2D {
target,
level,

3
tests/wpt/meta/webgl/idlharness.any.js.ini vendored
View file

@ -11,9 +11,6 @@
[WebGL2RenderingContext interface: operation getBufferSubData(GLenum, GLintptr, ArrayBufferView, optional GLuint, optional GLuint)]
expected: FAIL
[WebGL2RenderingContext interface: operation texImage3D(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLintptr)]
expected: FAIL
[WebGLRenderingContext interface: attribute drawingBufferColorSpace]
expected: FAIL

4
tests/wpt/webgl/meta/conformance2/context/context-sharing-texture2darray-texture3d-data-bug.html.ini vendored
View file

@ -1,4 +0,0 @@
[context-sharing-texture2darray-texture3d-data-bug.html]
expected: ERROR
[WebGL test #1]
expected: FAIL

12
tests/wpt/webgl/meta/conformance2/context/incorrect-context-object-behaviour.html.ini vendored
View file

@ -1,4 +1,12 @@
[incorrect-context-object-behaviour.html]
expected: ERROR
[WebGL test #1]
[WebGL test #84]
expected: FAIL
[WebGL test #89]
expected: FAIL
[WebGL test #92]
expected: FAIL
[WebGL test #93]
expected: FAIL

3
tests/wpt/webgl/meta/conformance2/context/methods-2.html.ini vendored
View file

@ -11,8 +11,5 @@
[WebGL test #3]
expected: FAIL
[WebGL test #4]
expected: FAIL
[WebGL test #7]
expected: FAIL

7
tests/wpt/webgl/meta/conformance2/misc/expando-loss-2.html.ini vendored
View file

@ -1,7 +0,0 @@
[expando-loss-2.html]
expected: ERROR
[WebGL test #15]
expected: FAIL
[WebGL test #16]
expected: FAIL

2
tests/wpt/webgl/meta/conformance2/misc/uninitialized-test-2.html.ini vendored
View file

@ -1,4 +1,4 @@
[uninitialized-test-2.html]
expected: ERROR
expected: CRASH
[WebGL test #1]
expected: FAIL

3
tests/wpt/webgl/meta/conformance2/misc/views-with-offsets.html.ini vendored
View file

@ -5,3 +5,6 @@
[WebGL test #47]
expected: FAIL
[WebGL test #48]
expected: FAIL

36
tests/wpt/webgl/meta/conformance2/renderbuffers/framebuffer-texture-layer.html.ini vendored
View file

@ -1,4 +1,36 @@
[framebuffer-texture-layer.html]
expected: ERROR
[WebGL test #1]
[WebGL test #3]
expected: FAIL
[WebGL test #5]
expected: FAIL
[WebGL test #6]
expected: FAIL
[WebGL test #10]
expected: FAIL
[WebGL test #11]
expected: FAIL
[WebGL test #12]
expected: FAIL
[WebGL test #13]
expected: FAIL
[WebGL test #14]
expected: FAIL
[WebGL test #15]
expected: FAIL
[WebGL test #16]
expected: FAIL
[WebGL test #17]
expected: FAIL
[WebGL test #18]
expected: FAIL

19
tests/wpt/webgl/meta/conformance2/rendering/blitframebuffer-test.html.ini vendored
View file

@ -1,5 +1,4 @@
[blitframebuffer-test.html]
expected: ERROR
[WebGL test #1]
expected: FAIL
@ -20,3 +19,21 @@
[WebGL test #9]
expected: FAIL
[WebGL test #11]
expected: FAIL
[WebGL test #13]
expected: FAIL
[WebGL test #16]
expected: FAIL
[WebGL test #18]
expected: FAIL
[WebGL test #19]
expected: FAIL
[WebGL test #20]
expected: FAIL

3
tests/wpt/webgl/meta/conformance2/rendering/depth-stencil-feedback-loop.html.ini vendored
View file

@ -1,6 +1,3 @@
[depth-stencil-feedback-loop.html]
[WebGL test #2]
expected: FAIL
[WebGL test #3]
expected: FAIL

6
tests/wpt/webgl/meta/conformance2/rendering/draw-with-integer-texture-base-level.html.ini vendored
View file

@ -1,6 +0,0 @@
[draw-with-integer-texture-base-level.html]
[WebGL test #0]
expected: FAIL
[WebGL test #2]
expected: FAIL

30
tests/wpt/webgl/meta/conformance2/rendering/framebuffer-mismatched-attachment-targets.html.ini vendored
View file

@ -67,3 +67,33 @@
[WebGL test #98]
expected: FAIL
[WebGL test #89]
expected: FAIL
[WebGL test #90]
expected: FAIL
[WebGL test #91]
expected: FAIL
[WebGL test #94]
expected: FAIL
[WebGL test #95]
expected: FAIL
[WebGL test #96]
expected: FAIL
[WebGL test #99]
expected: FAIL
[WebGL test #100]
expected: FAIL
[WebGL test #101]
expected: FAIL
[WebGL test #103]
expected: FAIL

4
tests/wpt/webgl/meta/conformance2/rendering/framebuffer-render-to-layer-angle-issue.html.ini vendored
View file

@ -1,4 +0,0 @@
[framebuffer-render-to-layer-angle-issue.html]
expected: ERROR
[WebGL test #1]
expected: FAIL

519
tests/wpt/webgl/meta/conformance2/rendering/framebuffer-render-to-layer.html.ini vendored
View file

@ -1,4 +1,519 @@
[framebuffer-render-to-layer.html]
expected: ERROR
[WebGL test #31]
[WebGL test #190]
expected: FAIL
[WebGL test #192]
expected: FAIL
[WebGL test #194]
expected: FAIL
[WebGL test #195]
expected: FAIL
[WebGL test #197]
expected: FAIL
[WebGL test #199]
expected: FAIL
[WebGL test #206]
expected: FAIL
[WebGL test #213]
expected: FAIL
[WebGL test #361]
expected: FAIL
[WebGL test #368]
expected: FAIL
[WebGL test #385]
expected: FAIL
[WebGL test #387]
expected: FAIL
[WebGL test #389]
expected: FAIL
[WebGL test #391]
expected: FAIL
[WebGL test #393]
expected: FAIL
[WebGL test #395]
expected: FAIL
[WebGL test #397]
expected: FAIL
[WebGL test #399]
expected: FAIL
[WebGL test #401]
expected: FAIL
[WebGL test #403]
expected: FAIL
[WebGL test #405]
expected: FAIL
[WebGL test #407]
expected: FAIL
[WebGL test #409]
expected: FAIL
[WebGL test #411]
expected: FAIL
[WebGL test #412]
expected: FAIL
[WebGL test #414]
expected: FAIL
[WebGL test #416]
expected: FAIL
[WebGL test #417]
expected: FAIL
[WebGL test #419]
expected: FAIL
[WebGL test #421]
expected: FAIL
[WebGL test #422]
expected: FAIL
[WebGL test #424]
expected: FAIL
[WebGL test #426]
expected: FAIL
[WebGL test #427]
expected: FAIL
[WebGL test #429]
expected: FAIL
[WebGL test #431]
expected: FAIL
[WebGL test #432]
expected: FAIL
[WebGL test #434]
expected: FAIL
[WebGL test #436]
expected: FAIL
[WebGL test #437]
expected: FAIL
[WebGL test #439]
expected: FAIL
[WebGL test #441]
expected: FAIL
[WebGL test #442]
expected: FAIL
[WebGL test #444]
expected: FAIL
[WebGL test #446]
expected: FAIL
[WebGL test #447]
expected: FAIL
[WebGL test #449]
expected: FAIL
[WebGL test #451]
expected: FAIL
[WebGL test #453]
expected: FAIL
[WebGL test #455]
expected: FAIL
[WebGL test #457]
expected: FAIL
[WebGL test #458]
expected: FAIL
[WebGL test #460]
expected: FAIL
[WebGL test #462]
expected: FAIL
[WebGL test #463]
expected: FAIL
[WebGL test #465]
expected: FAIL
[WebGL test #467]
expected: FAIL
[WebGL test #468]
expected: FAIL
[WebGL test #470]
expected: FAIL
[WebGL test #472]
expected: FAIL
[WebGL test #473]
expected: FAIL
[WebGL test #475]
expected: FAIL
[WebGL test #477]
expected: FAIL
[WebGL test #478]
expected: FAIL
[WebGL test #480]
expected: FAIL
[WebGL test #482]
expected: FAIL
[WebGL test #483]
expected: FAIL
[WebGL test #485]
expected: FAIL
[WebGL test #487]
expected: FAIL
[WebGL test #488]
expected: FAIL
[WebGL test #490]
expected: FAIL
[WebGL test #492]
expected: FAIL
[WebGL test #493]
expected: FAIL
[WebGL test #495]
expected: FAIL
[WebGL test #497]
expected: FAIL
[WebGL test #499]
expected: FAIL
[WebGL test #500]
expected: FAIL
[WebGL test #501]
expected: FAIL
[WebGL test #502]
expected: FAIL
[WebGL test #503]
expected: FAIL
[WebGL test #504]
expected: FAIL
[WebGL test #505]
expected: FAIL
[WebGL test #506]
expected: FAIL
[WebGL test #507]
expected: FAIL
[WebGL test #508]
expected: FAIL
[WebGL test #509]
expected: FAIL
[WebGL test #510]
expected: FAIL
[WebGL test #511]
expected: FAIL
[WebGL test #512]
expected: FAIL
[WebGL test #513]
expected: FAIL
[WebGL test #514]
expected: FAIL
[WebGL test #515]
expected: FAIL
[WebGL test #516]
expected: FAIL
[WebGL test #518]
expected: FAIL
[WebGL test #520]
expected: FAIL
[WebGL test #522]
expected: FAIL
[WebGL test #523]
expected: FAIL
[WebGL test #525]
expected: FAIL
[WebGL test #527]
expected: FAIL
[WebGL test #528]
expected: FAIL
[WebGL test #530]
expected: FAIL
[WebGL test #532]
expected: FAIL
[WebGL test #533]
expected: FAIL
[WebGL test #535]
expected: FAIL
[WebGL test #537]
expected: FAIL
[WebGL test #538]
expected: FAIL
[WebGL test #540]
expected: FAIL
[WebGL test #542]
expected: FAIL
[WebGL test #543]
expected: FAIL
[WebGL test #545]
expected: FAIL
[WebGL test #547]
expected: FAIL
[WebGL test #548]
expected: FAIL
[WebGL test #550]
expected: FAIL
[WebGL test #552]
expected: FAIL
[WebGL test #553]
expected: FAIL
[WebGL test #555]
expected: FAIL
[WebGL test #557]
expected: FAIL
[WebGL test #558]
expected: FAIL
[WebGL test #560]
expected: FAIL
[WebGL test #562]
expected: FAIL
[WebGL test #563]
expected: FAIL
[WebGL test #565]
expected: FAIL
[WebGL test #567]
expected: FAIL
[WebGL test #569]
expected: FAIL
[WebGL test #571]
expected: FAIL
[WebGL test #573]
expected: FAIL
[WebGL test #574]
expected: FAIL
[WebGL test #576]
expected: FAIL
[WebGL test #578]
expected: FAIL
[WebGL test #579]
expected: FAIL
[WebGL test #581]
expected: FAIL
[WebGL test #583]
expected: FAIL
[WebGL test #584]
expected: FAIL
[WebGL test #586]
expected: FAIL
[WebGL test #588]
expected: FAIL
[WebGL test #589]
expected: FAIL
[WebGL test #591]
expected: FAIL
[WebGL test #593]
expected: FAIL
[WebGL test #594]
expected: FAIL
[WebGL test #596]
expected: FAIL
[WebGL test #598]
expected: FAIL
[WebGL test #599]
expected: FAIL
[WebGL test #601]
expected: FAIL
[WebGL test #603]
expected: FAIL
[WebGL test #604]
expected: FAIL
[WebGL test #606]
expected: FAIL
[WebGL test #608]
expected: FAIL
[WebGL test #609]
expected: FAIL
[WebGL test #611]
expected: FAIL
[WebGL test #613]
expected: FAIL
[WebGL test #614]
expected: FAIL
[WebGL test #616]
expected: FAIL
[WebGL test #618]
expected: FAIL
[WebGL test #620]
expected: FAIL
[WebGL test #621]
expected: FAIL
[WebGL test #622]
expected: FAIL
[WebGL test #623]
expected: FAIL
[WebGL test #624]
expected: FAIL
[WebGL test #625]
expected: FAIL
[WebGL test #626]
expected: FAIL
[WebGL test #627]
expected: FAIL
[WebGL test #628]
expected: FAIL
[WebGL test #629]
expected: FAIL
[WebGL test #630]
expected: FAIL
[WebGL test #631]
expected: FAIL
[WebGL test #632]
expected: FAIL
[WebGL test #633]
expected: FAIL
[WebGL test #634]
expected: FAIL
[WebGL test #635]
expected: FAIL
[WebGL test #636]
expected: FAIL
[WebGL test #637]
expected: FAIL
[WebGL test #638]
expected: FAIL
[WebGL test #639]
expected: FAIL

15
tests/wpt/webgl/meta/conformance2/rendering/framebuffer-texture-changing-base-level.html.ini vendored
View file

@ -1,15 +0,0 @@
[framebuffer-texture-changing-base-level.html]
[WebGL test #10]
expected: FAIL
[WebGL test #14]
expected: FAIL
[WebGL test #17]
expected: FAIL
[WebGL test #2]
expected: FAIL
[WebGL test #6]
expected: FAIL

3
tests/wpt/webgl/meta/conformance2/rendering/framebuffer-texture-level1.html.ini vendored
View file

@ -1,6 +1,3 @@
[framebuffer-texture-level1.html]
[WebGL test #1]
expected: FAIL
[WebGL test #3]
expected: FAIL

7
tests/wpt/webgl/meta/conformance2/rendering/framebuffer-unsupported.html.ini vendored
View file

@ -1,5 +1,4 @@
[framebuffer-unsupported.html]
expected: ERROR
[WebGL test #4]
expected: FAIL
@ -8,3 +7,9 @@
[WebGL test #8]
expected: FAIL
[WebGL test #9]
expected: FAIL
[WebGL test #10]
expected: FAIL

3
tests/wpt/webgl/meta/conformance2/state/gl-get-calls.html.ini vendored
View file

@ -1,3 +0,0 @@
[gl-get-calls.html]
[WebGL test #87]
expected: FAIL

21
tests/wpt/webgl/meta/conformance2/state/gl-object-get-calls.html.ini vendored
View file

@ -8,27 +8,6 @@
[WebGL test #182]
expected: FAIL
[WebGL test #197]
expected: FAIL
[WebGL test #198]
expected: FAIL
[WebGL test #199]
expected: FAIL
[WebGL test #200]
expected: FAIL
[WebGL test #201]
expected: FAIL
[WebGL test #257]
expected: FAIL
[WebGL test #259]
expected: FAIL
[WebGL test #268]
expected: FAIL

4
tests/wpt/webgl/meta/conformance2/textures/misc/active-3d-texture-bug.html.ini vendored
View file

@ -1,4 +0,0 @@
[active-3d-texture-bug.html]
expected: ERROR
[WebGL test #1]
expected: FAIL

12
tests/wpt/webgl/meta/conformance2/textures/misc/copy-texture-image-same-texture.html.ini vendored
View file

@ -2,29 +2,17 @@
[WebGL test #11]
expected: FAIL
[WebGL test #12]
expected: FAIL
[WebGL test #16]
expected: FAIL
[WebGL test #18]
expected: FAIL
[WebGL test #19]
expected: FAIL
[WebGL test #2]
expected: FAIL
[WebGL test #3]
expected: FAIL
[WebGL test #6]
expected: FAIL
[WebGL test #8]
expected: FAIL
[WebGL test #9]
expected: FAIL

9
tests/wpt/webgl/meta/conformance2/textures/misc/copy-texture-image-webgl-specific.html.ini vendored
View file

@ -2,3 +2,12 @@
expected: ERROR
[WebGL test #1]
expected: FAIL
[WebGL test #2]
expected: FAIL
[WebGL test #3]
expected: FAIL
[WebGL test #4]
expected: FAIL

3
tests/wpt/webgl/meta/conformance2/textures/misc/generate-mipmap-with-large-base-level.html.ini vendored
View file

@ -1,6 +1,3 @@
[generate-mipmap-with-large-base-level.html]
[WebGL test #1]
expected: FAIL
[WebGL test #3]
expected: FAIL

636
tests/wpt/webgl/meta/conformance2/textures/misc/gl-get-tex-parameter.html.ini vendored
View file

@ -1,636 +0,0 @@
[gl-get-tex-parameter.html]
[WebGL test #0]
expected: FAIL
[WebGL test #101]
expected: FAIL
[WebGL test #102]
expected: FAIL
[WebGL test #103]
expected: FAIL
[WebGL test #104]
expected: FAIL
[WebGL test #109]
expected: FAIL
[WebGL test #110]
expected: FAIL
[WebGL test #111]
expected: FAIL
[WebGL test #112]
expected: FAIL
[WebGL test #117]
expected: FAIL
[WebGL test #118]
expected: FAIL
[WebGL test #119]
expected: FAIL
[WebGL test #120]
expected: FAIL
[WebGL test #125]
expected: FAIL
[WebGL test #126]
expected: FAIL
[WebGL test #127]
expected: FAIL
[WebGL test #128]
expected: FAIL
[WebGL test #13]
expected: FAIL
[WebGL test #133]
expected: FAIL
[WebGL test #134]
expected: FAIL
[WebGL test #135]
expected: FAIL
[WebGL test #136]
expected: FAIL
[WebGL test #137]
expected: FAIL
[WebGL test #138]
expected: FAIL
[WebGL test #139]
expected: FAIL
[WebGL test #14]
expected: FAIL
[WebGL test #140]
expected: FAIL
[WebGL test #141]
expected: FAIL
[WebGL test #142]
expected: FAIL
[WebGL test #143]
expected: FAIL
[WebGL test #144]
expected: FAIL
[WebGL test #145]
expected: FAIL
[WebGL test #146]
expected: FAIL
[WebGL test #147]
expected: FAIL
[WebGL test #148]
expected: FAIL
[WebGL test #149]
expected: FAIL
[WebGL test #15]
expected: FAIL
[WebGL test #150]
expected: FAIL
[WebGL test #151]
expected: FAIL
[WebGL test #152]
expected: FAIL
[WebGL test #153]
expected: FAIL
[WebGL test #154]
expected: FAIL
[WebGL test #155]
expected: FAIL
[WebGL test #156]
expected: FAIL
[WebGL test #157]
expected: FAIL
[WebGL test #158]
expected: FAIL
[WebGL test #159]
expected: FAIL
[WebGL test #16]
expected: FAIL
[WebGL test #160]
expected: FAIL
[WebGL test #161]
expected: FAIL
[WebGL test #162]
expected: FAIL
[WebGL test #163]
expected: FAIL
[WebGL test #164]
expected: FAIL
[WebGL test #165]
expected: FAIL
[WebGL test #166]
expected: FAIL
[WebGL test #167]
expected: FAIL
[WebGL test #168]
expected: FAIL
[WebGL test #169]
expected: FAIL
[WebGL test #170]
expected: FAIL
[WebGL test #171]
expected: FAIL
[WebGL test #172]
expected: FAIL
[WebGL test #173]
expected: FAIL
[WebGL test #174]
expected: FAIL
[WebGL test #175]
expected: FAIL
[WebGL test #176]
expected: FAIL
[WebGL test #177]
expected: FAIL
[WebGL test #178]
expected: FAIL
[WebGL test #179]
expected: FAIL
[WebGL test #180]
expected: FAIL
[WebGL test #181]
expected: FAIL
[WebGL test #182]
expected: FAIL
[WebGL test #183]
expected: FAIL
[WebGL test #184]
expected: FAIL
[WebGL test #185]
expected: FAIL
[WebGL test #186]
expected: FAIL
[WebGL test #187]
expected: FAIL
[WebGL test #188]
expected: FAIL
[WebGL test #189]
expected: FAIL
[WebGL test #190]
expected: FAIL
[WebGL test #191]
expected: FAIL
[WebGL test #192]
expected: FAIL
[WebGL test #197]
expected: FAIL
[WebGL test #198]
expected: FAIL
[WebGL test #199]
expected: FAIL
[WebGL test #200]
expected: FAIL
[WebGL test #205]
expected: FAIL
[WebGL test #206]
expected: FAIL
[WebGL test #207]
expected: FAIL
[WebGL test #208]
expected: FAIL
[WebGL test #21]
expected: FAIL
[WebGL test #213]
expected: FAIL
[WebGL test #214]
expected: FAIL
[WebGL test #215]
expected: FAIL
[WebGL test #216]
expected: FAIL
[WebGL test #22]
expected: FAIL
[WebGL test #221]
expected: FAIL
[WebGL test #222]
expected: FAIL
[WebGL test #223]
expected: FAIL
[WebGL test #224]
expected: FAIL
[WebGL test #229]
expected: FAIL
[WebGL test #23]
expected: FAIL
[WebGL test #230]
expected: FAIL
[WebGL test #231]
expected: FAIL
[WebGL test #232]
expected: FAIL
[WebGL test #237]
expected: FAIL
[WebGL test #238]
expected: FAIL
[WebGL test #239]
expected: FAIL
[WebGL test #24]
expected: FAIL
[WebGL test #240]
expected: FAIL
[WebGL test #241]
expected: FAIL
[WebGL test #242]
expected: FAIL
[WebGL test #243]
expected: FAIL
[WebGL test #244]
expected: FAIL
[WebGL test #245]
expected: FAIL
[WebGL test #246]
expected: FAIL
[WebGL test #247]
expected: FAIL
[WebGL test #248]
expected: FAIL
[WebGL test #249]
expected: FAIL
[WebGL test #250]
expected: FAIL
[WebGL test #251]
expected: FAIL
[WebGL test #252]
expected: FAIL
[WebGL test #253]
expected: FAIL
[WebGL test #254]
expected: FAIL
[WebGL test #255]
expected: FAIL
[WebGL test #256]
expected: FAIL
[WebGL test #257]
expected: FAIL
[WebGL test #259]
expected: FAIL
[WebGL test #261]
expected: FAIL
[WebGL test #262]
expected: FAIL
[WebGL test #263]
expected: FAIL
[WebGL test #264]
expected: FAIL
[WebGL test #265]
expected: FAIL
[WebGL test #266]
expected: FAIL
[WebGL test #267]
expected: FAIL
[WebGL test #268]
expected: FAIL
[WebGL test #269]
expected: FAIL
[WebGL test #270]
expected: FAIL
[WebGL test #271]
expected: FAIL
[WebGL test #272]
expected: FAIL
[WebGL test #273]
expected: FAIL
[WebGL test #274]
expected: FAIL
[WebGL test #275]
expected: FAIL
[WebGL test #276]
expected: FAIL
[WebGL test #277]
expected: FAIL
[WebGL test #278]
expected: FAIL
[WebGL test #279]
expected: FAIL
[WebGL test #280]
expected: FAIL
[WebGL test #281]
expected: FAIL
[WebGL test #282]
expected: FAIL
[WebGL test #283]
expected: FAIL
[WebGL test #284]
expected: FAIL
[WebGL test #285]
expected: FAIL
[WebGL test #286]
expected: FAIL
[WebGL test #287]
expected: FAIL
[WebGL test #288]
expected: FAIL
[WebGL test #289]
expected: FAIL
[WebGL test #29]
expected: FAIL
[WebGL test #290]
expected: FAIL
[WebGL test #291]
expected: FAIL
[WebGL test #292]
expected: FAIL
[WebGL test #293]
expected: FAIL
[WebGL test #294]
expected: FAIL
[WebGL test #295]
expected: FAIL
[WebGL test #296]
expected: FAIL
[WebGL test #30]
expected: FAIL
[WebGL test #301]
expected: FAIL
[WebGL test #302]
expected: FAIL
[WebGL test #303]
expected: FAIL
[WebGL test #304]
expected: FAIL
[WebGL test #309]
expected: FAIL
[WebGL test #31]
expected: FAIL
[WebGL test #310]
expected: FAIL
[WebGL test #311]
expected: FAIL
[WebGL test #312]
expected: FAIL
[WebGL test #313]
expected: FAIL
[WebGL test #32]
expected: FAIL
[WebGL test #37]
expected: FAIL
[WebGL test #38]
expected: FAIL
[WebGL test #39]
expected: FAIL
[WebGL test #40]
expected: FAIL
[WebGL test #45]
expected: FAIL
[WebGL test #46]
expected: FAIL
[WebGL test #47]
expected: FAIL
[WebGL test #48]
expected: FAIL
[WebGL test #5]
expected: FAIL
[WebGL test #53]
expected: FAIL
[WebGL test #54]
expected: FAIL
[WebGL test #55]
expected: FAIL
[WebGL test #56]
expected: FAIL
[WebGL test #6]
expected: FAIL
[WebGL test #61]
expected: FAIL
[WebGL test #62]
expected: FAIL
[WebGL test #63]
expected: FAIL
[WebGL test #64]
expected: FAIL
[WebGL test #69]
expected: FAIL
[WebGL test #7]
expected: FAIL
[WebGL test #70]
expected: FAIL
[WebGL test #71]
expected: FAIL
[WebGL test #72]
expected: FAIL
[WebGL test #77]
expected: FAIL
[WebGL test #78]
expected: FAIL
[WebGL test #79]
expected: FAIL
[WebGL test #8]
expected: FAIL
[WebGL test #80]
expected: FAIL
[WebGL test #85]
expected: FAIL
[WebGL test #86]
expected: FAIL
[WebGL test #87]
expected: FAIL
[WebGL test #88]
expected: FAIL
[WebGL test #93]
expected: FAIL
[WebGL test #94]
expected: FAIL
[WebGL test #95]
expected: FAIL
[WebGL test #96]
expected: FAIL

9
tests/wpt/webgl/meta/conformance2/textures/misc/tex-3d-mipmap-levels-intel-bug.html.ini vendored
View file

@ -1,13 +1,4 @@
[tex-3d-mipmap-levels-intel-bug.html]
[WebGL test #1]
expected: FAIL
[WebGL test #2]
expected: FAIL
[WebGL test #3]
expected: FAIL
[WebGL test #4]
expected: FAIL

2
tests/wpt/webgl/meta/conformance2/textures/misc/tex-3d-size-limit.html.ini vendored
View file

@ -1,4 +1,4 @@
[tex-3d-size-limit.html]
expected: ERROR
expected: CRASH
[WebGL test #1]
expected: FAIL

9
tests/wpt/webgl/meta/conformance2/textures/misc/tex-base-level-bug.html.ini vendored
View file

@ -1,9 +0,0 @@
[tex-base-level-bug.html]
[WebGL test #1]
expected: FAIL
[WebGL test #3]
expected: FAIL
[WebGL test #5]
expected: FAIL

6
tests/wpt/webgl/meta/conformance2/textures/misc/tex-image-and-sub-image-with-array-buffer-view-sub-source.html.ini vendored
View file

@ -8,3 +8,9 @@
[WebGL test #8]
expected: FAIL
[WebGL test #11]
expected: FAIL
[WebGL test #12]
expected: FAIL

7
tests/wpt/webgl/meta/conformance2/textures/misc/tex-input-validation.html.ini vendored
View file

@ -12,8 +12,11 @@
[WebGL test #68]
expected: FAIL
[WebGL test #70]
[WebGL test #76]
expected: FAIL
[WebGL test #71]
[WebGL test #77]
expected: FAIL
[WebGL test #79]
expected: FAIL

20
tests/wpt/webgl/meta/conformance2/textures/misc/tex-mipmap-levels.html.ini vendored
View file

@ -6,26 +6,8 @@
[WebGL test #11]
expected: FAIL
[WebGL test #14]
expected: FAIL
[WebGL test #15]
expected: FAIL
[WebGL test #21]
expected: FAIL
[WebGL test #23]
expected: FAIL
[WebGL test #24]
expected: FAIL
[WebGL test #4]
expected: FAIL
[WebGL test #5]
expected: FAIL
[WebGL test #9]
[WebGL test #25]
expected: FAIL

2
tests/wpt/webgl/meta/conformance2/textures/misc/tex-new-formats.html.ini vendored
View file

@ -1,4 +1,4 @@
[tex-new-formats.html]
expected: ERROR
[WebGL test #8]
[WebGL test #10]
expected: FAIL

3
tests/wpt/webgl/meta/conformance2/textures/misc/tex-subimage3d-pixel-buffer-bug.html.ini vendored
View file

@ -1,8 +1,5 @@
[tex-subimage3d-pixel-buffer-bug.html]
expected: ERROR
[WebGL test #1]
expected: FAIL
[WebGL test #2]
expected: FAIL

15
tests/wpt/webgl/meta/conformance2/textures/misc/tex-unpack-params.html.ini vendored
View file

@ -8,3 +8,18 @@
[WebGL test #11]
expected: FAIL
[WebGL test #13]
expected: FAIL
[WebGL test #14]
expected: FAIL
[WebGL test #15]
expected: FAIL
[WebGL test #16]
expected: FAIL
[WebGL test #17]
expected: FAIL

181
tests/wpt/webgl/meta/conformance2/uniforms/incompatible-texture-type-for-sampler.html.ini vendored
View file

@ -1,181 +1,2 @@
[incompatible-texture-type-for-sampler.html]
expected: ERROR
[WebGL test #1]
expected: FAIL
[WebGL test #10]
expected: FAIL
[WebGL test #11]
expected: FAIL
[WebGL test #12]
expected: FAIL
[WebGL test #13]
expected: FAIL
[WebGL test #14]
expected: FAIL
[WebGL test #15]
expected: FAIL
[WebGL test #16]
expected: FAIL
[WebGL test #17]
expected: FAIL
[WebGL test #18]
expected: FAIL
[WebGL test #19]
expected: FAIL
[WebGL test #2]
expected: FAIL
[WebGL test #20]
expected: FAIL
[WebGL test #21]
expected: FAIL
[WebGL test #22]
expected: FAIL
[WebGL test #23]
expected: FAIL
[WebGL test #24]
expected: FAIL
[WebGL test #25]
expected: FAIL
[WebGL test #26]
expected: FAIL
[WebGL test #27]
expected: FAIL
[WebGL test #28]
expected: FAIL
[WebGL test #29]
expected: FAIL
[WebGL test #3]
expected: FAIL
[WebGL test #30]
expected: FAIL
[WebGL test #31]
expected: FAIL
[WebGL test #32]
expected: FAIL
[WebGL test #33]
expected: FAIL
[WebGL test #34]
expected: FAIL
[WebGL test #35]
expected: FAIL
[WebGL test #36]
expected: FAIL
[WebGL test #37]
expected: FAIL
[WebGL test #38]
expected: FAIL
[WebGL test #39]
expected: FAIL
[WebGL test #4]
expected: FAIL
[WebGL test #40]
expected: FAIL
[WebGL test #41]
expected: FAIL
[WebGL test #42]
expected: FAIL
[WebGL test #43]
expected: FAIL
[WebGL test #44]
expected: FAIL
[WebGL test #45]
expected: FAIL
[WebGL test #46]
expected: FAIL
[WebGL test #47]
expected: FAIL
[WebGL test #48]
expected: FAIL
[WebGL test #49]
expected: FAIL
[WebGL test #5]
expected: FAIL
[WebGL test #50]
expected: FAIL
[WebGL test #51]
expected: FAIL
[WebGL test #52]
expected: FAIL
[WebGL test #53]
expected: FAIL
[WebGL test #54]
expected: FAIL
[WebGL test #55]
expected: FAIL
[WebGL test #56]
expected: FAIL
[WebGL test #57]
expected: FAIL
[WebGL test #58]
expected: FAIL
[WebGL test #59]
expected: FAIL
[WebGL test #6]
expected: FAIL
[WebGL test #60]
expected: FAIL
[WebGL test #7]
expected: FAIL
[WebGL test #8]
expected: FAIL
[WebGL test #9]
expected: FAIL
disabled: too many tests to cause TIMEOUT