script/dom/webgl/extensions/
extensions.rs1use 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
35const DEFAULT_DISABLED_TEX_TYPES_WEBGL1: [GLenum; 2] = [
39 constants::FLOAT,
40 OESTextureHalfFloatConstants::HALF_FLOAT_OES,
41];
42
43const DEFAULT_NOT_FILTERABLE_TEX_TYPES: [GLenum; 2] = [
47 constants::FLOAT,
48 OESTextureHalfFloatConstants::HALF_FLOAT_OES,
49];
50
51const 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
62const 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
71const DEFAULT_DISABLED_GET_TEX_PARAMETER_NAMES_WEBGL1: [GLenum; 1] =
75 [EXTTextureFilterAnisotropicConstants::TEXTURE_MAX_ANISOTROPY_EXT];
76
77const DEFAULT_DISABLED_GET_TEX_PARAMETER_NAMES_WEBGL2: [GLenum; 1] =
81 [EXTTextureFilterAnisotropicConstants::TEXTURE_MAX_ANISOTROPY_EXT];
82
83const DEFAULT_DISABLED_GET_VERTEX_ATTRIB_NAMES_WEBGL1: [GLenum; 1] =
87 [ANGLEInstancedArraysConstants::VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE];
88
89#[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 hint_targets: FxHashSet<GLenum>,
99 disabled_get_parameter_names: FxHashSet<GLenum>,
101 disabled_get_tex_parameter_names: FxHashSet<GLenum>,
103 disabled_get_vertex_attrib_names: FxHashSet<GLenum>,
105 element_index_uint_enabled: bool,
107 blend_minmax_enabled: bool,
109 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#[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#[derive(Eq, Hash, MallocSizeOf, PartialEq)]
487struct TexFormatType(TexFormat, u32);