Skip to main content

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