Implement EXT_frag_depth

components/canvas_traits/webgl.rs

@@ -122,7 +122,9 @@ pub enum WebGLVersion {
 }
 
 /// Defines the GLSL version supported by the WebGL backend contexts.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, MallocSizeOf, PartialEq, Serialize)]
+#[derive(
+    Clone, Copy, Debug, Deserialize, Eq, MallocSizeOf, Ord, PartialEq, PartialOrd, Serialize,
+)]
 pub struct WebGLSLVersion {
     /// Major GLSL version
     pub major: u32,

components/script/dom/webgl_extensions/ext/extfragdepth.rs

@@ -0,0 +1,62 @@
+/* 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 super::{WebGLExtension, WebGLExtensionSpec, WebGLExtensions};
+use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::webglrenderingcontext::WebGLRenderingContext;
+use canvas_traits::webgl::{WebGLSLVersion, WebGLVersion};
+use dom_struct::dom_struct;
+
+#[dom_struct]
+pub struct EXTFragDepth {
+    reflector_: Reflector,
+}
+
+impl EXTFragDepth {
+    fn new_inherited() -> EXTFragDepth {
+        Self {
+            reflector_: Reflector::new(),
+        }
+    }
+}
+
+impl WebGLExtension for EXTFragDepth {
+    type Extension = Self;
+
+    fn new(ctx: &WebGLRenderingContext) -> DomRoot<Self> {
+        reflect_dom_object(Box::new(Self::new_inherited()), &*ctx.global())
+    }
+
+    fn spec() -> WebGLExtensionSpec {
+        WebGLExtensionSpec::Specific(WebGLVersion::WebGL1)
+    }
+
+    fn is_supported(ext: &WebGLExtensions) -> bool {
+        let min_glsl_version = if ext.is_gles() {
+            WebGLSLVersion { major: 3, minor: 0 }
+        } else {
+            WebGLSLVersion {
+                major: 1,
+                minor: 10,
+            }
+        };
+        match (
+            ext.is_gles(),
+            ext.is_min_glsl_version_satisfied(min_glsl_version),
+        ) {
+            // ANGLE's shader translator can't translate ESSL1 exts to ESSL3. (bug
+            // 1524804)
+            (true, true) => false,
+            (true, false) => ext.supports_gl_extension("GL_EXT_frag_depth"),
+            (false, is_min_glsl_version_satisfied) => is_min_glsl_version_satisfied,
+        }
+    }
+
+    fn enable(_ext: &WebGLExtensions) {}
+
+    fn name() -> &'static str {
+        "EXT_frag_depth"
+    }
+}

components/script/dom/webgl_extensions/ext/mod.rs

@@ -8,6 +8,7 @@ use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGL
 pub mod angleinstancedarrays;
 pub mod extblendminmax;
 pub mod extcolorbufferhalffloat;
+pub mod extfragdepth;
 pub mod extshadertexturelod;
 pub mod exttexturefilteranisotropic;
 pub mod oeselementindexuint;

components/script/dom/webgl_extensions/extensions.rs

@@ -18,7 +18,7 @@ use crate::dom::oestexturehalffloat::OESTextureHalfFloat;
 use crate::dom::webglcolorbufferfloat::WEBGLColorBufferFloat;
 use crate::dom::webglrenderingcontext::WebGLRenderingContext;
 use crate::dom::webgltexture::TexCompression;
-use canvas_traits::webgl::{GlType, TexFormat, WebGLVersion};
+use canvas_traits::webgl::{GlType, TexFormat, WebGLSLVersion, WebGLVersion};
 use fnv::{FnvHashMap, FnvHashSet};
 use js::jsapi::JSObject;
 use malloc_size_of::MallocSizeOf;
@@ -165,15 +165,21 @@ pub struct WebGLExtensions {
     features: DomRefCell<WebGLExtensionFeatures>,
     webgl_version: WebGLVersion,
     api_type: GlType,
+    glsl_version: WebGLSLVersion,
 }
 
 impl WebGLExtensions {
-    pub fn new(webgl_version: WebGLVersion, api_type: GlType) -> WebGLExtensions {
+    pub fn new(
+        webgl_version: WebGLVersion,
+        api_type: GlType,
+        glsl_version: WebGLSLVersion,
+    ) -> WebGLExtensions {
         Self {
             extensions: DomRefCell::new(HashMap::new()),
             features: DomRefCell::new(WebGLExtensionFeatures::new(webgl_version)),
             webgl_version,
             api_type,
+            glsl_version,
         }
     }
 
@@ -399,6 +405,7 @@ impl WebGLExtensions {
         self.register::<ext::angleinstancedarrays::ANGLEInstancedArrays>();
         self.register::<ext::extblendminmax::EXTBlendMinmax>();
         self.register::<ext::extcolorbufferhalffloat::EXTColorBufferHalfFloat>();
+        self.register::<ext::extfragdepth::EXTFragDepth>();
         self.register::<ext::extshadertexturelod::EXTShaderTextureLod>();
         self.register::<ext::exttexturefilteranisotropic::EXTTextureFilterAnisotropic>();
         self.register::<ext::oeselementindexuint::OESElementIndexUint>();
@@ -433,6 +440,10 @@ impl WebGLExtensions {
         self.is_enabled::<WEBGLColorBufferFloat>() || self.is_enabled::<OESTextureFloat>()
     }
 
+    pub fn is_min_glsl_version_satisfied(&self, min_glsl_version: WebGLSLVersion) -> bool {
+        self.glsl_version >= min_glsl_version
+    }
+
     pub fn is_half_float_buffer_renderable(&self) -> bool {
         self.is_enabled::<EXTColorBufferHalfFloat>() || self.is_enabled::<OESTextureHalfFloat>()
     }

components/script/dom/webglrenderingcontext.rs

@@ -257,7 +257,11 @@ impl WebGLRenderingContext {
                 // what was requested
                 size: Cell::new(size),
                 current_clear_color: Cell::new((0.0, 0.0, 0.0, 0.0)),
-                extension_manager: WebGLExtensions::new(webgl_version, ctx_data.api_type),
+                extension_manager: WebGLExtensions::new(
+                    webgl_version,
+                    ctx_data.api_type,
+                    ctx_data.glsl_version,
+                ),
                 capabilities: Default::default(),
                 default_vao: Default::default(),
                 current_vao: Default::default(),

components/script/dom/webglshader.rs

@@ -8,6 +8,7 @@ use crate::dom::bindings::inheritance::Castable;
 use crate::dom::bindings::reflector::{reflect_dom_object, DomObject};
 use crate::dom::bindings::root::DomRoot;
 use crate::dom::bindings::str::DOMString;
+use crate::dom::webgl_extensions::ext::extfragdepth::EXTFragDepth;
 use crate::dom::webgl_extensions::ext::extshadertexturelod::EXTShaderTextureLod;
 use crate::dom::webgl_extensions::ext::oesstandardderivatives::OESStandardDerivatives;
 use crate::dom::webgl_extensions::WebGLExtensions;
@@ -235,6 +236,7 @@ impl WebGLShader {
 
             OES_standard_derivatives: ext.is_enabled::<OESStandardDerivatives>() as c_int,
             EXT_shader_texture_lod: ext.is_enabled::<EXTShaderTextureLod>() as c_int,
+            EXT_frag_depth: ext.is_enabled::<EXTFragDepth>() as c_int,
 
             FragmentPrecisionHigh: 1,
             ..default_validator()

components/script/dom/webidls/EXTFragDepth.webidl

@@ -0,0 +1,11 @@
+/* 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/. */
+/*
+ * WebGL IDL definitions from the Khronos specification:
+ * https://www.khronos.org/registry/webgl/extensions/EXT_frag_depth/
+ */
+
+[NoInterfaceObject, Exposed=Window]
+interface EXTFragDepth {
+}; // interface EXT_frag_depth