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

script/dom/webgl/extensions/
extensions.rs
