script/dom/webgl/extensions/
extensions.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::collections::HashMap;
6use std::iter::FromIterator;
7use std::ptr::NonNull;
8
9use js::jsapi::JSObject;
10use malloc_size_of::MallocSizeOf;
11use rustc_hash::{FxHashMap, FxHashSet};
12use script_bindings::str::DOMString;
13use servo_canvas_traits::webgl::{GlType, TexFormat, WebGLSLVersion, WebGLVersion};
14type GLenum = u32;
15
16use script_bindings::cell::DomRefCell;
17
18use super::wrapper::{TypedWebGLExtensionWrapper, WebGLExtensionWrapper};
19use super::{WebGLExtension, WebGLExtensionSpec, ext};
20use crate::dom::bindings::codegen::Bindings::ANGLEInstancedArraysBinding::ANGLEInstancedArraysConstants;
21use crate::dom::bindings::codegen::Bindings::EXTTextureFilterAnisotropicBinding::EXTTextureFilterAnisotropicConstants;
22use crate::dom::bindings::codegen::Bindings::OESStandardDerivativesBinding::OESStandardDerivativesConstants;
23use crate::dom::bindings::codegen::Bindings::OESTextureHalfFloatBinding::OESTextureHalfFloatConstants;
24use crate::dom::bindings::codegen::Bindings::OESVertexArrayObjectBinding::OESVertexArrayObjectConstants;
25use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
26use crate::dom::bindings::trace::JSTraceable;
27use crate::dom::webgl::extensions::extcolorbufferhalffloat::EXTColorBufferHalfFloat;
28use crate::dom::webgl::extensions::oestexturefloat::OESTextureFloat;
29use crate::dom::webgl::extensions::oestexturehalffloat::OESTextureHalfFloat;
30use crate::dom::webgl::extensions::webglcolorbufferfloat::WEBGLColorBufferFloat;
31use crate::dom::webgl::webglrenderingcontext::WebGLRenderingContext;
32use crate::dom::webgl::webgltexture::TexCompression;
33
34// Data types that are implemented for texImage2D and texSubImage2D in a WebGL 1.0 context
35// but must trigger a InvalidValue error until the related WebGL Extensions are enabled.
36// Example: https://www.khronos.org/registry/webgl/extensions/OES_texture_float/
37const DEFAULT_DISABLED_TEX_TYPES_WEBGL1: [GLenum; 2] = [
38    constants::FLOAT,
39    OESTextureHalfFloatConstants::HALF_FLOAT_OES,
40];
41
42// Data types that are implemented for textures in WebGLRenderingContext
43// but not allowed to use with linear filtering until the related WebGL Extensions are enabled.
44// Example: https://www.khronos.org/registry/webgl/extensions/OES_texture_float_linear/
45const DEFAULT_NOT_FILTERABLE_TEX_TYPES: [GLenum; 2] = [
46    constants::FLOAT,
47    OESTextureHalfFloatConstants::HALF_FLOAT_OES,
48];
49
50// Param names that are implemented for glGetParameter in a WebGL 1.0 context
51// but must trigger a InvalidEnum error until the related WebGL Extensions are enabled.
52// Example: https://www.khronos.org/registry/webgl/extensions/OES_standard_derivatives/
53const DEFAULT_DISABLED_GET_PARAMETER_NAMES_WEBGL1: [GLenum; 3] = [
54    EXTTextureFilterAnisotropicConstants::MAX_TEXTURE_MAX_ANISOTROPY_EXT,
55    OESStandardDerivativesConstants::FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
56    OESVertexArrayObjectConstants::VERTEX_ARRAY_BINDING_OES,
57];
58
59// Param names that are implemented for glGetParameter in a WebGL 2.0 context
60// but must trigger a InvalidEnum error until the related WebGL Extensions are enabled.
61// Example: https://www.khronos.org/registry/webgl/extensions/EXT_texture_filter_anisotropic/
62const DEFAULT_DISABLED_GET_PARAMETER_NAMES_WEBGL2: [GLenum; 1] =
63    [EXTTextureFilterAnisotropicConstants::MAX_TEXTURE_MAX_ANISOTROPY_EXT];
64
65// Param names that are implemented for glGetTexParameter in a WebGL 1.0 context
66// but must trigger a InvalidEnum error until the related WebGL Extensions are enabled.
67// Example: https://www.khronos.org/registry/webgl/extensions/OES_standard_derivatives/
68const DEFAULT_DISABLED_GET_TEX_PARAMETER_NAMES_WEBGL1: [GLenum; 1] =
69    [EXTTextureFilterAnisotropicConstants::TEXTURE_MAX_ANISOTROPY_EXT];
70
71// Param names that are implemented for glGetTexParameter in a WebGL 2.0 context
72// but must trigger a InvalidEnum error until the related WebGL Extensions are enabled.
73// Example: https://www.khronos.org/registry/webgl/extensions/EXT_texture_filter_anisotropic/
74const DEFAULT_DISABLED_GET_TEX_PARAMETER_NAMES_WEBGL2: [GLenum; 1] =
75    [EXTTextureFilterAnisotropicConstants::TEXTURE_MAX_ANISOTROPY_EXT];
76
77// Param names that are implemented for glGetVertexAttrib in a WebGL 1.0 context
78// but must trigger a InvalidEnum error until the related WebGL Extensions are enabled.
79// Example: https://www.khronos.org/registry/webgl/extensions/ANGLE_instanced_arrays/
80const DEFAULT_DISABLED_GET_VERTEX_ATTRIB_NAMES_WEBGL1: [GLenum; 1] =
81    [ANGLEInstancedArraysConstants::VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE];
82
83/// WebGL features that are enabled/disabled by WebGL Extensions.
84#[derive(JSTraceable, MallocSizeOf)]
85struct WebGLExtensionFeatures {
86    gl_extensions: FxHashSet<String>,
87    disabled_tex_types: FxHashSet<GLenum>,
88    not_filterable_tex_types: FxHashSet<GLenum>,
89    #[no_trace]
90    effective_tex_internal_formats: FxHashMap<TexFormatType, TexFormat>,
91    /// WebGL Hint() targets enabled by extensions.
92    hint_targets: FxHashSet<GLenum>,
93    /// WebGL GetParameter() names enabled by extensions.
94    disabled_get_parameter_names: FxHashSet<GLenum>,
95    /// WebGL GetTexParameter() names enabled by extensions.
96    disabled_get_tex_parameter_names: FxHashSet<GLenum>,
97    /// WebGL GetAttribVertex() names enabled by extensions.
98    disabled_get_vertex_attrib_names: FxHashSet<GLenum>,
99    /// WebGL OES_element_index_uint extension.
100    element_index_uint_enabled: bool,
101    /// WebGL EXT_blend_minmax extension.
102    blend_minmax_enabled: bool,
103    /// WebGL supported texture compression formats enabled by extensions.
104    tex_compression_formats: FxHashMap<GLenum, TexCompression>,
105}
106
107impl WebGLExtensionFeatures {
108    fn new(webgl_version: WebGLVersion) -> Self {
109        let (
110            disabled_tex_types,
111            disabled_get_parameter_names,
112            disabled_get_tex_parameter_names,
113            disabled_get_vertex_attrib_names,
114            not_filterable_tex_types,
115            element_index_uint_enabled,
116            blend_minmax_enabled,
117        ) = match webgl_version {
118            WebGLVersion::WebGL1 => (
119                DEFAULT_DISABLED_TEX_TYPES_WEBGL1.iter().cloned().collect(),
120                DEFAULT_DISABLED_GET_PARAMETER_NAMES_WEBGL1
121                    .iter()
122                    .cloned()
123                    .collect(),
124                DEFAULT_DISABLED_GET_TEX_PARAMETER_NAMES_WEBGL1
125                    .iter()
126                    .cloned()
127                    .collect(),
128                DEFAULT_DISABLED_GET_VERTEX_ATTRIB_NAMES_WEBGL1
129                    .iter()
130                    .cloned()
131                    .collect(),
132                DEFAULT_NOT_FILTERABLE_TEX_TYPES.iter().cloned().collect(),
133                false,
134                false,
135            ),
136            WebGLVersion::WebGL2 => (
137                Default::default(),
138                DEFAULT_DISABLED_GET_PARAMETER_NAMES_WEBGL2
139                    .iter()
140                    .cloned()
141                    .collect(),
142                DEFAULT_DISABLED_GET_TEX_PARAMETER_NAMES_WEBGL2
143                    .iter()
144                    .cloned()
145                    .collect(),
146                Default::default(),
147                Default::default(),
148                true,
149                true,
150            ),
151        };
152        Self {
153            gl_extensions: Default::default(),
154            disabled_tex_types,
155            not_filterable_tex_types,
156            effective_tex_internal_formats: Default::default(),
157            hint_targets: Default::default(),
158            disabled_get_parameter_names,
159            disabled_get_tex_parameter_names,
160            disabled_get_vertex_attrib_names,
161            element_index_uint_enabled,
162            blend_minmax_enabled,
163            tex_compression_formats: Default::default(),
164        }
165    }
166}
167
168/// Handles the list of implemented, supported and enabled WebGL extensions.
169#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
170#[derive(JSTraceable, MallocSizeOf)]
171pub(crate) struct WebGLExtensions {
172    extensions: DomRefCell<HashMap<String, Box<dyn WebGLExtensionWrapper>>>,
173    features: DomRefCell<WebGLExtensionFeatures>,
174    #[no_trace]
175    webgl_version: WebGLVersion,
176    #[no_trace]
177    api_type: GlType,
178    #[no_trace]
179    glsl_version: WebGLSLVersion,
180}
181
182impl WebGLExtensions {
183    pub(crate) fn new(
184        webgl_version: WebGLVersion,
185        api_type: GlType,
186        glsl_version: WebGLSLVersion,
187    ) -> WebGLExtensions {
188        Self {
189            extensions: DomRefCell::new(HashMap::new()),
190            features: DomRefCell::new(WebGLExtensionFeatures::new(webgl_version)),
191            webgl_version,
192            api_type,
193            glsl_version,
194        }
195    }
196
197    pub(crate) fn init_once<F>(&self, cb: F)
198    where
199        F: FnOnce() -> String,
200    {
201        if self.extensions.borrow().is_empty() {
202            let gl_str = cb();
203            self.features.borrow_mut().gl_extensions =
204                FxHashSet::from_iter(gl_str.split(&[',', ' '][..]).map(|s| s.into()));
205            self.register_all_extensions();
206        }
207    }
208
209    pub(crate) fn register<T: 'static + WebGLExtension + JSTraceable + MallocSizeOf>(&self) {
210        let name = T::name().to_uppercase();
211        self.extensions
212            .borrow_mut()
213            .insert(name, Box::new(TypedWebGLExtensionWrapper::<T>::new()));
214    }
215
216    pub(crate) fn get_supported_extensions(&self) -> Vec<&'static str> {
217        self.extensions
218            .borrow()
219            .iter()
220            .filter(|v| {
221                if let WebGLExtensionSpec::Specific(version) = v.1.spec() &&
222                    self.webgl_version != version
223                {
224                    return false;
225                }
226                v.1.is_supported(self)
227            })
228            .map(|ref v| v.1.name())
229            .collect()
230    }
231
232    pub(crate) fn get_or_init_extension(
233        &self,
234        name: &DOMString,
235        ctx: &WebGLRenderingContext,
236    ) -> Option<NonNull<JSObject>> {
237        let name = name.to_uppercase();
238        self.extensions.borrow().get(&name).and_then(|extension| {
239            if extension.is_supported(self) {
240                Some(extension.instance_or_init(ctx, self))
241            } else {
242                None
243            }
244        })
245    }
246
247    pub(crate) fn is_enabled<T>(&self) -> bool
248    where
249        T: 'static + WebGLExtension + JSTraceable + MallocSizeOf,
250    {
251        let name = T::name().to_uppercase();
252        self.extensions
253            .borrow()
254            .get(&name)
255            .is_some_and(|ext| ext.is_enabled())
256    }
257
258    pub(crate) fn supports_gl_extension(&self, name: &str) -> bool {
259        self.features.borrow().gl_extensions.contains(name)
260    }
261
262    pub(crate) fn supports_any_gl_extension(&self, names: &[&str]) -> bool {
263        let features = self.features.borrow();
264        names
265            .iter()
266            .any(|name| features.gl_extensions.contains(*name))
267    }
268
269    pub(crate) fn supports_all_gl_extension(&self, names: &[&str]) -> bool {
270        let features = self.features.borrow();
271        names
272            .iter()
273            .all(|name| features.gl_extensions.contains(*name))
274    }
275
276    pub(crate) fn enable_tex_type(&self, data_type: GLenum) {
277        self.features
278            .borrow_mut()
279            .disabled_tex_types
280            .remove(&data_type);
281    }
282
283    pub(crate) fn is_tex_type_enabled(&self, data_type: GLenum) -> bool {
284        !self
285            .features
286            .borrow()
287            .disabled_tex_types
288            .contains(&data_type)
289    }
290
291    pub(crate) fn add_effective_tex_internal_format(
292        &self,
293        source_internal_format: TexFormat,
294        source_data_type: u32,
295        effective_internal_format: TexFormat,
296    ) {
297        let format = TexFormatType(source_internal_format, source_data_type);
298        self.features
299            .borrow_mut()
300            .effective_tex_internal_formats
301            .insert(format, effective_internal_format);
302    }
303
304    pub(crate) fn get_effective_tex_internal_format(
305        &self,
306        source_internal_format: TexFormat,
307        source_data_type: u32,
308    ) -> TexFormat {
309        let format = TexFormatType(source_internal_format, source_data_type);
310        *(self
311            .features
312            .borrow()
313            .effective_tex_internal_formats
314            .get(&format)
315            .unwrap_or(&source_internal_format))
316    }
317
318    pub(crate) fn enable_filterable_tex_type(&self, text_data_type: GLenum) {
319        self.features
320            .borrow_mut()
321            .not_filterable_tex_types
322            .remove(&text_data_type);
323    }
324
325    pub(crate) fn is_filterable(&self, text_data_type: u32) -> bool {
326        !self
327            .features
328            .borrow()
329            .not_filterable_tex_types
330            .contains(&text_data_type)
331    }
332
333    pub(crate) fn enable_hint_target(&self, name: GLenum) {
334        self.features.borrow_mut().hint_targets.insert(name);
335    }
336
337    pub(crate) fn is_hint_target_enabled(&self, name: GLenum) -> bool {
338        self.features.borrow().hint_targets.contains(&name)
339    }
340
341    pub(crate) fn enable_get_parameter_name(&self, name: GLenum) {
342        self.features
343            .borrow_mut()
344            .disabled_get_parameter_names
345            .remove(&name);
346    }
347
348    pub(crate) fn is_get_parameter_name_enabled(&self, name: GLenum) -> bool {
349        !self
350            .features
351            .borrow()
352            .disabled_get_parameter_names
353            .contains(&name)
354    }
355
356    pub(crate) fn enable_get_tex_parameter_name(&self, name: GLenum) {
357        self.features
358            .borrow_mut()
359            .disabled_get_tex_parameter_names
360            .remove(&name);
361    }
362
363    pub(crate) fn is_get_tex_parameter_name_enabled(&self, name: GLenum) -> bool {
364        !self
365            .features
366            .borrow()
367            .disabled_get_tex_parameter_names
368            .contains(&name)
369    }
370
371    pub(crate) fn enable_get_vertex_attrib_name(&self, name: GLenum) {
372        self.features
373            .borrow_mut()
374            .disabled_get_vertex_attrib_names
375            .remove(&name);
376    }
377
378    pub(crate) fn is_get_vertex_attrib_name_enabled(&self, name: GLenum) -> bool {
379        !self
380            .features
381            .borrow()
382            .disabled_get_vertex_attrib_names
383            .contains(&name)
384    }
385
386    pub(crate) fn add_tex_compression_formats(&self, formats: &[TexCompression]) {
387        let formats: FxHashMap<GLenum, TexCompression> = formats
388            .iter()
389            .map(|&compression| (compression.format.as_gl_constant(), compression))
390            .collect();
391
392        self.features
393            .borrow_mut()
394            .tex_compression_formats
395            .extend(formats.iter());
396    }
397
398    pub(crate) fn get_tex_compression_format(&self, format_id: GLenum) -> Option<TexCompression> {
399        self.features
400            .borrow()
401            .tex_compression_formats
402            .get(&format_id)
403            .cloned()
404    }
405
406    pub(crate) fn get_tex_compression_ids(&self) -> Vec<GLenum> {
407        self.features
408            .borrow()
409            .tex_compression_formats
410            .keys()
411            .copied()
412            .collect()
413    }
414
415    fn register_all_extensions(&self) {
416        self.register::<ext::angleinstancedarrays::ANGLEInstancedArrays>();
417        self.register::<ext::extblendminmax::EXTBlendMinmax>();
418        self.register::<ext::extcolorbufferhalffloat::EXTColorBufferHalfFloat>();
419        self.register::<ext::extfragdepth::EXTFragDepth>();
420        self.register::<ext::extshadertexturelod::EXTShaderTextureLod>();
421        self.register::<ext::exttexturefilteranisotropic::EXTTextureFilterAnisotropic>();
422        self.register::<ext::oeselementindexuint::OESElementIndexUint>();
423        self.register::<ext::oesstandardderivatives::OESStandardDerivatives>();
424        self.register::<ext::oestexturefloat::OESTextureFloat>();
425        self.register::<ext::oestexturefloatlinear::OESTextureFloatLinear>();
426        self.register::<ext::oestexturehalffloat::OESTextureHalfFloat>();
427        self.register::<ext::oestexturehalffloatlinear::OESTextureHalfFloatLinear>();
428        self.register::<ext::oesvertexarrayobject::OESVertexArrayObject>();
429        self.register::<ext::webglcolorbufferfloat::WEBGLColorBufferFloat>();
430        self.register::<ext::webglcompressedtextureetc1::WEBGLCompressedTextureETC1>();
431        self.register::<ext::webglcompressedtextures3tc::WEBGLCompressedTextureS3TC>();
432    }
433
434    pub(crate) fn enable_element_index_uint(&self) {
435        self.features.borrow_mut().element_index_uint_enabled = true;
436    }
437
438    pub(crate) fn is_element_index_uint_enabled(&self) -> bool {
439        self.features.borrow().element_index_uint_enabled
440    }
441
442    pub(crate) fn enable_blend_minmax(&self) {
443        self.features.borrow_mut().blend_minmax_enabled = true;
444    }
445
446    pub(crate) fn is_blend_minmax_enabled(&self) -> bool {
447        self.features.borrow().blend_minmax_enabled
448    }
449
450    pub(crate) fn is_float_buffer_renderable(&self) -> bool {
451        self.is_enabled::<WEBGLColorBufferFloat>() || self.is_enabled::<OESTextureFloat>()
452    }
453
454    pub(crate) fn is_min_glsl_version_satisfied(&self, min_glsl_version: WebGLSLVersion) -> bool {
455        self.glsl_version >= min_glsl_version
456    }
457
458    pub(crate) fn is_half_float_buffer_renderable(&self) -> bool {
459        self.is_enabled::<EXTColorBufferHalfFloat>() || self.is_enabled::<OESTextureHalfFloat>()
460    }
461
462    pub(crate) fn effective_type(&self, type_: u32) -> u32 {
463        if type_ == OESTextureHalfFloatConstants::HALF_FLOAT_OES &&
464            !self.supports_gl_extension("GL_OES_texture_half_float")
465        {
466            return glow::HALF_FLOAT;
467        }
468        type_
469    }
470
471    pub(crate) fn is_gles(&self) -> bool {
472        self.api_type == GlType::Gles
473    }
474}
475
476// Helper structs
477#[derive(Eq, Hash, MallocSizeOf, PartialEq)]
478struct TexFormatType(TexFormat, u32);
script/dom/webgl/extensions/extensions.rs

script/dom/webgl/extensions/
extensions.rs
