1#![allow(non_camel_case_types,non_upper_case_globals,unsafe_op_in_unsafe_fn,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::enum_variant_names,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]
4
5use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
6use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
7use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
8use crate::codegen::GenericBindings::HTMLMediaElementBinding::HTMLMediaElement_Binding;
9use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
10use crate::codegen::GenericBindings::WebGLObjectBinding::WebGLObject_Binding;
11use crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLContextAttributes;
12use crate::import::base::*;
13
14pub type GLint64 = i64;
15
16pub type GLuint64 = u64;
17
18pub use self::GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence as Uint32List;
19
20pub use self::WebGL2RenderingContext_Binding::{WebGL2RenderingContextConstants, Wrap, WebGL2RenderingContextMethods, GetProtoObject, DefineDOMInterface};
21pub mod WebGL2RenderingContext_Binding {
22use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
23use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
24use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
25use crate::codegen::GenericBindings::HTMLMediaElementBinding::HTMLMediaElement_Binding;
26use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
27use crate::codegen::GenericBindings::WebGLObjectBinding::WebGLObject_Binding;
28use crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLContextAttributes;
29use crate::import::module::*;
30
31unsafe extern "C" fn copyBufferSubData<D: DomTypes>
32(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
33 let mut result = false;
34 wrap_panic(&mut || result = (|| {
35 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
36 let this = &*(this as *const D::WebGL2RenderingContext);
37 let args = &*args;
38 let argc = args.argc_;
39
40 if argc < 5 {
41 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.copyBufferSubData\".");
42 return false;
43 }
44 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
45 Ok(ConversionResult::Success(value)) => value,
46 Ok(ConversionResult::Failure(error)) => {
47 throw_type_error(cx.raw_cx(), &error);
48 return false;
49
50 }
51 _ => {
52 return false;
53
54 },
55 }
56 ;
57 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
58 Ok(ConversionResult::Success(value)) => value,
59 Ok(ConversionResult::Failure(error)) => {
60 throw_type_error(cx.raw_cx(), &error);
61 return false;
62
63 }
64 _ => {
65 return false;
66
67 },
68 }
69 ;
70 let arg2: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
71 Ok(ConversionResult::Success(value)) => value,
72 Ok(ConversionResult::Failure(error)) => {
73 throw_type_error(cx.raw_cx(), &error);
74 return false;
75
76 }
77 _ => {
78 return false;
79
80 },
81 }
82 ;
83 let arg3: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
84 Ok(ConversionResult::Success(value)) => value,
85 Ok(ConversionResult::Failure(error)) => {
86 throw_type_error(cx.raw_cx(), &error);
87 return false;
88
89 }
90 _ => {
91 return false;
92
93 },
94 }
95 ;
96 let arg4: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
97 Ok(ConversionResult::Success(value)) => value,
98 Ok(ConversionResult::Failure(error)) => {
99 throw_type_error(cx.raw_cx(), &error);
100 return false;
101
102 }
103 _ => {
104 return false;
105
106 },
107 }
108 ;
109 let result: () = this.CopyBufferSubData(arg0, arg1, arg2, arg3, arg4);
110
111 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
112 return true;
113 })());
114 result
115}
116
117
118static copyBufferSubData_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
119
120pub(crate) fn init_copyBufferSubData_methodinfo<D: DomTypes>() {
121 copyBufferSubData_methodinfo.set(JSJitInfo {
122 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
123 method: Some(copyBufferSubData::<D>)
124 },
125 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
126 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
127 },
128 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
129 _bitfield_align_1: [],
130 _bitfield_1: __BindgenBitfieldUnit::new(
131 new_jsjitinfo_bitfield_1!(
132 JSJitInfo_OpType::Method as u8,
133 JSJitInfo_AliasSet::AliasEverything as u8,
134 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
135 false,
136 false,
137 false,
138 false,
139 false,
140 false,
141 0,
142 ).to_ne_bytes()
143 ),
144});
145}
146unsafe extern "C" fn getBufferSubData<D: DomTypes>
147(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
148 let mut result = false;
149 wrap_panic(&mut || result = (|| {
150 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
151 let this = &*(this as *const D::WebGL2RenderingContext);
152 let args = &*args;
153 let argc = args.argc_;
154
155 if argc < 3 {
156 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getBufferSubData\".");
157 return false;
158 }
159 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
160 Ok(ConversionResult::Success(value)) => value,
161 Ok(ConversionResult::Failure(error)) => {
162 throw_type_error(cx.raw_cx(), &error);
163 return false;
164
165 }
166 _ => {
167 return false;
168
169 },
170 }
171 ;
172 let arg1: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
173 Ok(ConversionResult::Success(value)) => value,
174 Ok(ConversionResult::Failure(error)) => {
175 throw_type_error(cx.raw_cx(), &error);
176 return false;
177
178 }
179 _ => {
180 return false;
181
182 },
183 }
184 ;
185 let arg2: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(2)).get().is_object() {
186 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(2)).get().to_object()) {
187 Ok(val) => val,
188 Err(()) => {
189 throw_type_error(cx.raw_cx(), "value is not a typed array.");
190 return false;
191
192 }
193 }
194
195 } else {
196 throw_type_error(cx.raw_cx(), "Value is not an object.");
197 return false;
198
199 };
200 auto_root!(&in(cx) let arg2 = arg2);
201 let arg3: u32 = if args.get(3).is_undefined() {
202 0
203 } else {
204 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
205 Ok(ConversionResult::Success(value)) => value,
206 Ok(ConversionResult::Failure(error)) => {
207 throw_type_error(cx.raw_cx(), &error);
208 return false;
209
210 }
211 _ => {
212 return false;
213
214 },
215 }
216
217 };
218 let arg4: u32 = if args.get(4).is_undefined() {
219 0
220 } else {
221 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
222 Ok(ConversionResult::Success(value)) => value,
223 Ok(ConversionResult::Failure(error)) => {
224 throw_type_error(cx.raw_cx(), &error);
225 return false;
226
227 }
228 _ => {
229 return false;
230
231 },
232 }
233
234 };
235 let result: () = this.GetBufferSubData(arg0, arg1, arg2, arg3, arg4);
236
237 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
238 return true;
239 })());
240 result
241}
242
243
244static getBufferSubData_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
245
246pub(crate) fn init_getBufferSubData_methodinfo<D: DomTypes>() {
247 getBufferSubData_methodinfo.set(JSJitInfo {
248 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
249 method: Some(getBufferSubData::<D>)
250 },
251 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
252 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
253 },
254 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
255 _bitfield_align_1: [],
256 _bitfield_1: __BindgenBitfieldUnit::new(
257 new_jsjitinfo_bitfield_1!(
258 JSJitInfo_OpType::Method as u8,
259 JSJitInfo_AliasSet::AliasEverything as u8,
260 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
261 false,
262 false,
263 false,
264 false,
265 false,
266 false,
267 0,
268 ).to_ne_bytes()
269 ),
270});
271}
272unsafe extern "C" fn blitFramebuffer<D: DomTypes>
273(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
274 let mut result = false;
275 wrap_panic(&mut || result = (|| {
276 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
277 let this = &*(this as *const D::WebGL2RenderingContext);
278 let args = &*args;
279 let argc = args.argc_;
280
281 if argc < 10 {
282 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.blitFramebuffer\".");
283 return false;
284 }
285 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
286 Ok(ConversionResult::Success(value)) => value,
287 Ok(ConversionResult::Failure(error)) => {
288 throw_type_error(cx.raw_cx(), &error);
289 return false;
290
291 }
292 _ => {
293 return false;
294
295 },
296 }
297 ;
298 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
299 Ok(ConversionResult::Success(value)) => value,
300 Ok(ConversionResult::Failure(error)) => {
301 throw_type_error(cx.raw_cx(), &error);
302 return false;
303
304 }
305 _ => {
306 return false;
307
308 },
309 }
310 ;
311 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
312 Ok(ConversionResult::Success(value)) => value,
313 Ok(ConversionResult::Failure(error)) => {
314 throw_type_error(cx.raw_cx(), &error);
315 return false;
316
317 }
318 _ => {
319 return false;
320
321 },
322 }
323 ;
324 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
325 Ok(ConversionResult::Success(value)) => value,
326 Ok(ConversionResult::Failure(error)) => {
327 throw_type_error(cx.raw_cx(), &error);
328 return false;
329
330 }
331 _ => {
332 return false;
333
334 },
335 }
336 ;
337 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
338 Ok(ConversionResult::Success(value)) => value,
339 Ok(ConversionResult::Failure(error)) => {
340 throw_type_error(cx.raw_cx(), &error);
341 return false;
342
343 }
344 _ => {
345 return false;
346
347 },
348 }
349 ;
350 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
351 Ok(ConversionResult::Success(value)) => value,
352 Ok(ConversionResult::Failure(error)) => {
353 throw_type_error(cx.raw_cx(), &error);
354 return false;
355
356 }
357 _ => {
358 return false;
359
360 },
361 }
362 ;
363 let arg6: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
364 Ok(ConversionResult::Success(value)) => value,
365 Ok(ConversionResult::Failure(error)) => {
366 throw_type_error(cx.raw_cx(), &error);
367 return false;
368
369 }
370 _ => {
371 return false;
372
373 },
374 }
375 ;
376 let arg7: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
377 Ok(ConversionResult::Success(value)) => value,
378 Ok(ConversionResult::Failure(error)) => {
379 throw_type_error(cx.raw_cx(), &error);
380 return false;
381
382 }
383 _ => {
384 return false;
385
386 },
387 }
388 ;
389 let arg8: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(8)), ConversionBehavior::Default) {
390 Ok(ConversionResult::Success(value)) => value,
391 Ok(ConversionResult::Failure(error)) => {
392 throw_type_error(cx.raw_cx(), &error);
393 return false;
394
395 }
396 _ => {
397 return false;
398
399 },
400 }
401 ;
402 let arg9: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(9)), ConversionBehavior::Default) {
403 Ok(ConversionResult::Success(value)) => value,
404 Ok(ConversionResult::Failure(error)) => {
405 throw_type_error(cx.raw_cx(), &error);
406 return false;
407
408 }
409 _ => {
410 return false;
411
412 },
413 }
414 ;
415 let result: () = this.BlitFramebuffer(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
416
417 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
418 return true;
419 })());
420 result
421}
422
423
424static blitFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
425
426pub(crate) fn init_blitFramebuffer_methodinfo<D: DomTypes>() {
427 blitFramebuffer_methodinfo.set(JSJitInfo {
428 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
429 method: Some(blitFramebuffer::<D>)
430 },
431 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
432 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
433 },
434 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
435 _bitfield_align_1: [],
436 _bitfield_1: __BindgenBitfieldUnit::new(
437 new_jsjitinfo_bitfield_1!(
438 JSJitInfo_OpType::Method as u8,
439 JSJitInfo_AliasSet::AliasEverything as u8,
440 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
441 false,
442 false,
443 false,
444 false,
445 false,
446 false,
447 0,
448 ).to_ne_bytes()
449 ),
450});
451}
452unsafe extern "C" fn framebufferTextureLayer<D: DomTypes>
453(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
454 let mut result = false;
455 wrap_panic(&mut || result = (|| {
456 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
457 let this = &*(this as *const D::WebGL2RenderingContext);
458 let args = &*args;
459 let argc = args.argc_;
460
461 if argc < 5 {
462 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.framebufferTextureLayer\".");
463 return false;
464 }
465 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
466 Ok(ConversionResult::Success(value)) => value,
467 Ok(ConversionResult::Failure(error)) => {
468 throw_type_error(cx.raw_cx(), &error);
469 return false;
470
471 }
472 _ => {
473 return false;
474
475 },
476 }
477 ;
478 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
479 Ok(ConversionResult::Success(value)) => value,
480 Ok(ConversionResult::Failure(error)) => {
481 throw_type_error(cx.raw_cx(), &error);
482 return false;
483
484 }
485 _ => {
486 return false;
487
488 },
489 }
490 ;
491 let arg2: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(2)).get().is_object() {
492 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(2)), SafeJSContext::from_ptr(cx.raw_cx())) {
493 Ok(val) => val,
494 Err(()) => {
495 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
496 return false;
497
498 }
499 }
500 )
501 } else if HandleValue::from_raw(args.get(2)).get().is_null_or_undefined() {
502 None
503 } else {
504 throw_type_error(cx.raw_cx(), "Value is not an object.");
505 return false;
506
507 };
508 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
509 Ok(ConversionResult::Success(value)) => value,
510 Ok(ConversionResult::Failure(error)) => {
511 throw_type_error(cx.raw_cx(), &error);
512 return false;
513
514 }
515 _ => {
516 return false;
517
518 },
519 }
520 ;
521 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
522 Ok(ConversionResult::Success(value)) => value,
523 Ok(ConversionResult::Failure(error)) => {
524 throw_type_error(cx.raw_cx(), &error);
525 return false;
526
527 }
528 _ => {
529 return false;
530
531 },
532 }
533 ;
534 let result: () = this.FramebufferTextureLayer(arg0, arg1, arg2.as_deref(), arg3, arg4);
535
536 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
537 return true;
538 })());
539 result
540}
541
542
543static framebufferTextureLayer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
544
545pub(crate) fn init_framebufferTextureLayer_methodinfo<D: DomTypes>() {
546 framebufferTextureLayer_methodinfo.set(JSJitInfo {
547 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
548 method: Some(framebufferTextureLayer::<D>)
549 },
550 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
551 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
552 },
553 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
554 _bitfield_align_1: [],
555 _bitfield_1: __BindgenBitfieldUnit::new(
556 new_jsjitinfo_bitfield_1!(
557 JSJitInfo_OpType::Method as u8,
558 JSJitInfo_AliasSet::AliasEverything as u8,
559 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
560 false,
561 false,
562 false,
563 false,
564 false,
565 false,
566 0,
567 ).to_ne_bytes()
568 ),
569});
570}
571unsafe extern "C" fn invalidateFramebuffer<D: DomTypes>
572(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
573 let mut result = false;
574 wrap_panic(&mut || result = (|| {
575 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
576 let this = &*(this as *const D::WebGL2RenderingContext);
577 let args = &*args;
578 let argc = args.argc_;
579
580 if argc < 2 {
581 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.invalidateFramebuffer\".");
582 return false;
583 }
584 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
585 Ok(ConversionResult::Success(value)) => value,
586 Ok(ConversionResult::Failure(error)) => {
587 throw_type_error(cx.raw_cx(), &error);
588 return false;
589
590 }
591 _ => {
592 return false;
593
594 },
595 }
596 ;
597 let arg1: Vec<u32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
598 Ok(ConversionResult::Success(value)) => value,
599 Ok(ConversionResult::Failure(error)) => {
600 throw_type_error(cx.raw_cx(), &error);
601 return false;
602
603 }
604 _ => {
605 return false;
606
607 },
608 }
609 ;
610 let result: () = this.InvalidateFramebuffer(arg0, arg1);
611
612 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
613 return true;
614 })());
615 result
616}
617
618
619static invalidateFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
620
621pub(crate) fn init_invalidateFramebuffer_methodinfo<D: DomTypes>() {
622 invalidateFramebuffer_methodinfo.set(JSJitInfo {
623 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
624 method: Some(invalidateFramebuffer::<D>)
625 },
626 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
627 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
628 },
629 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
630 _bitfield_align_1: [],
631 _bitfield_1: __BindgenBitfieldUnit::new(
632 new_jsjitinfo_bitfield_1!(
633 JSJitInfo_OpType::Method as u8,
634 JSJitInfo_AliasSet::AliasEverything as u8,
635 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
636 false,
637 false,
638 false,
639 false,
640 false,
641 false,
642 0,
643 ).to_ne_bytes()
644 ),
645});
646}
647unsafe extern "C" fn invalidateSubFramebuffer<D: DomTypes>
648(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
649 let mut result = false;
650 wrap_panic(&mut || result = (|| {
651 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
652 let this = &*(this as *const D::WebGL2RenderingContext);
653 let args = &*args;
654 let argc = args.argc_;
655
656 if argc < 6 {
657 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.invalidateSubFramebuffer\".");
658 return false;
659 }
660 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
661 Ok(ConversionResult::Success(value)) => value,
662 Ok(ConversionResult::Failure(error)) => {
663 throw_type_error(cx.raw_cx(), &error);
664 return false;
665
666 }
667 _ => {
668 return false;
669
670 },
671 }
672 ;
673 let arg1: Vec<u32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
674 Ok(ConversionResult::Success(value)) => value,
675 Ok(ConversionResult::Failure(error)) => {
676 throw_type_error(cx.raw_cx(), &error);
677 return false;
678
679 }
680 _ => {
681 return false;
682
683 },
684 }
685 ;
686 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
687 Ok(ConversionResult::Success(value)) => value,
688 Ok(ConversionResult::Failure(error)) => {
689 throw_type_error(cx.raw_cx(), &error);
690 return false;
691
692 }
693 _ => {
694 return false;
695
696 },
697 }
698 ;
699 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
700 Ok(ConversionResult::Success(value)) => value,
701 Ok(ConversionResult::Failure(error)) => {
702 throw_type_error(cx.raw_cx(), &error);
703 return false;
704
705 }
706 _ => {
707 return false;
708
709 },
710 }
711 ;
712 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
713 Ok(ConversionResult::Success(value)) => value,
714 Ok(ConversionResult::Failure(error)) => {
715 throw_type_error(cx.raw_cx(), &error);
716 return false;
717
718 }
719 _ => {
720 return false;
721
722 },
723 }
724 ;
725 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
726 Ok(ConversionResult::Success(value)) => value,
727 Ok(ConversionResult::Failure(error)) => {
728 throw_type_error(cx.raw_cx(), &error);
729 return false;
730
731 }
732 _ => {
733 return false;
734
735 },
736 }
737 ;
738 let result: () = this.InvalidateSubFramebuffer(arg0, arg1, arg2, arg3, arg4, arg5);
739
740 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
741 return true;
742 })());
743 result
744}
745
746
747static invalidateSubFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
748
749pub(crate) fn init_invalidateSubFramebuffer_methodinfo<D: DomTypes>() {
750 invalidateSubFramebuffer_methodinfo.set(JSJitInfo {
751 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
752 method: Some(invalidateSubFramebuffer::<D>)
753 },
754 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
755 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
756 },
757 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
758 _bitfield_align_1: [],
759 _bitfield_1: __BindgenBitfieldUnit::new(
760 new_jsjitinfo_bitfield_1!(
761 JSJitInfo_OpType::Method as u8,
762 JSJitInfo_AliasSet::AliasEverything as u8,
763 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
764 false,
765 false,
766 false,
767 false,
768 false,
769 false,
770 0,
771 ).to_ne_bytes()
772 ),
773});
774}
775unsafe extern "C" fn readBuffer<D: DomTypes>
776(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
777 let mut result = false;
778 wrap_panic(&mut || result = (|| {
779 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
780 let this = &*(this as *const D::WebGL2RenderingContext);
781 let args = &*args;
782 let argc = args.argc_;
783
784 if argc < 1 {
785 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.readBuffer\".");
786 return false;
787 }
788 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
789 Ok(ConversionResult::Success(value)) => value,
790 Ok(ConversionResult::Failure(error)) => {
791 throw_type_error(cx.raw_cx(), &error);
792 return false;
793
794 }
795 _ => {
796 return false;
797
798 },
799 }
800 ;
801 let result: () = this.ReadBuffer(arg0);
802
803 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
804 return true;
805 })());
806 result
807}
808
809
810static readBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
811
812pub(crate) fn init_readBuffer_methodinfo<D: DomTypes>() {
813 readBuffer_methodinfo.set(JSJitInfo {
814 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
815 method: Some(readBuffer::<D>)
816 },
817 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
818 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
819 },
820 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
821 _bitfield_align_1: [],
822 _bitfield_1: __BindgenBitfieldUnit::new(
823 new_jsjitinfo_bitfield_1!(
824 JSJitInfo_OpType::Method as u8,
825 JSJitInfo_AliasSet::AliasEverything as u8,
826 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
827 false,
828 false,
829 false,
830 false,
831 false,
832 false,
833 0,
834 ).to_ne_bytes()
835 ),
836});
837}
838unsafe extern "C" fn getInternalformatParameter<D: DomTypes>
839(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
840 let mut result = false;
841 wrap_panic(&mut || result = (|| {
842 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
843 let this = &*(this as *const D::WebGL2RenderingContext);
844 let args = &*args;
845 let argc = args.argc_;
846
847 if argc < 3 {
848 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getInternalformatParameter\".");
849 return false;
850 }
851 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
852 Ok(ConversionResult::Success(value)) => value,
853 Ok(ConversionResult::Failure(error)) => {
854 throw_type_error(cx.raw_cx(), &error);
855 return false;
856
857 }
858 _ => {
859 return false;
860
861 },
862 }
863 ;
864 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
865 Ok(ConversionResult::Success(value)) => value,
866 Ok(ConversionResult::Failure(error)) => {
867 throw_type_error(cx.raw_cx(), &error);
868 return false;
869
870 }
871 _ => {
872 return false;
873
874 },
875 }
876 ;
877 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
878 Ok(ConversionResult::Success(value)) => value,
879 Ok(ConversionResult::Failure(error)) => {
880 throw_type_error(cx.raw_cx(), &error);
881 return false;
882
883 }
884 _ => {
885 return false;
886
887 },
888 }
889 ;
890 rooted!(&in(cx) let mut retval: JSVal);
891 let result: () = this.GetInternalformatParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, arg2, retval.handle_mut());
892
893 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
894 return true;
895 })());
896 result
897}
898
899
900static getInternalformatParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
901
902pub(crate) fn init_getInternalformatParameter_methodinfo<D: DomTypes>() {
903 getInternalformatParameter_methodinfo.set(JSJitInfo {
904 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
905 method: Some(getInternalformatParameter::<D>)
906 },
907 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
908 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
909 },
910 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
911 _bitfield_align_1: [],
912 _bitfield_1: __BindgenBitfieldUnit::new(
913 new_jsjitinfo_bitfield_1!(
914 JSJitInfo_OpType::Method as u8,
915 JSJitInfo_AliasSet::AliasEverything as u8,
916 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
917 false,
918 false,
919 false,
920 false,
921 false,
922 false,
923 0,
924 ).to_ne_bytes()
925 ),
926});
927}
928unsafe extern "C" fn renderbufferStorageMultisample<D: DomTypes>
929(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
930 let mut result = false;
931 wrap_panic(&mut || result = (|| {
932 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
933 let this = &*(this as *const D::WebGL2RenderingContext);
934 let args = &*args;
935 let argc = args.argc_;
936
937 if argc < 5 {
938 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.renderbufferStorageMultisample\".");
939 return false;
940 }
941 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
942 Ok(ConversionResult::Success(value)) => value,
943 Ok(ConversionResult::Failure(error)) => {
944 throw_type_error(cx.raw_cx(), &error);
945 return false;
946
947 }
948 _ => {
949 return false;
950
951 },
952 }
953 ;
954 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
955 Ok(ConversionResult::Success(value)) => value,
956 Ok(ConversionResult::Failure(error)) => {
957 throw_type_error(cx.raw_cx(), &error);
958 return false;
959
960 }
961 _ => {
962 return false;
963
964 },
965 }
966 ;
967 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
968 Ok(ConversionResult::Success(value)) => value,
969 Ok(ConversionResult::Failure(error)) => {
970 throw_type_error(cx.raw_cx(), &error);
971 return false;
972
973 }
974 _ => {
975 return false;
976
977 },
978 }
979 ;
980 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
981 Ok(ConversionResult::Success(value)) => value,
982 Ok(ConversionResult::Failure(error)) => {
983 throw_type_error(cx.raw_cx(), &error);
984 return false;
985
986 }
987 _ => {
988 return false;
989
990 },
991 }
992 ;
993 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
994 Ok(ConversionResult::Success(value)) => value,
995 Ok(ConversionResult::Failure(error)) => {
996 throw_type_error(cx.raw_cx(), &error);
997 return false;
998
999 }
1000 _ => {
1001 return false;
1002
1003 },
1004 }
1005 ;
1006 let result: () = this.RenderbufferStorageMultisample(arg0, arg1, arg2, arg3, arg4);
1007
1008 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1009 return true;
1010 })());
1011 result
1012}
1013
1014
1015static renderbufferStorageMultisample_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1016
1017pub(crate) fn init_renderbufferStorageMultisample_methodinfo<D: DomTypes>() {
1018 renderbufferStorageMultisample_methodinfo.set(JSJitInfo {
1019 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1020 method: Some(renderbufferStorageMultisample::<D>)
1021 },
1022 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1023 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1024 },
1025 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1026 _bitfield_align_1: [],
1027 _bitfield_1: __BindgenBitfieldUnit::new(
1028 new_jsjitinfo_bitfield_1!(
1029 JSJitInfo_OpType::Method as u8,
1030 JSJitInfo_AliasSet::AliasEverything as u8,
1031 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1032 false,
1033 false,
1034 false,
1035 false,
1036 false,
1037 false,
1038 0,
1039 ).to_ne_bytes()
1040 ),
1041});
1042}
1043unsafe extern "C" fn texStorage2D<D: DomTypes>
1044(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1045 let mut result = false;
1046 wrap_panic(&mut || result = (|| {
1047 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1048 let this = &*(this as *const D::WebGL2RenderingContext);
1049 let args = &*args;
1050 let argc = args.argc_;
1051
1052 if argc < 5 {
1053 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.texStorage2D\".");
1054 return false;
1055 }
1056 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1057 Ok(ConversionResult::Success(value)) => value,
1058 Ok(ConversionResult::Failure(error)) => {
1059 throw_type_error(cx.raw_cx(), &error);
1060 return false;
1061
1062 }
1063 _ => {
1064 return false;
1065
1066 },
1067 }
1068 ;
1069 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1070 Ok(ConversionResult::Success(value)) => value,
1071 Ok(ConversionResult::Failure(error)) => {
1072 throw_type_error(cx.raw_cx(), &error);
1073 return false;
1074
1075 }
1076 _ => {
1077 return false;
1078
1079 },
1080 }
1081 ;
1082 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
1083 Ok(ConversionResult::Success(value)) => value,
1084 Ok(ConversionResult::Failure(error)) => {
1085 throw_type_error(cx.raw_cx(), &error);
1086 return false;
1087
1088 }
1089 _ => {
1090 return false;
1091
1092 },
1093 }
1094 ;
1095 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
1096 Ok(ConversionResult::Success(value)) => value,
1097 Ok(ConversionResult::Failure(error)) => {
1098 throw_type_error(cx.raw_cx(), &error);
1099 return false;
1100
1101 }
1102 _ => {
1103 return false;
1104
1105 },
1106 }
1107 ;
1108 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
1109 Ok(ConversionResult::Success(value)) => value,
1110 Ok(ConversionResult::Failure(error)) => {
1111 throw_type_error(cx.raw_cx(), &error);
1112 return false;
1113
1114 }
1115 _ => {
1116 return false;
1117
1118 },
1119 }
1120 ;
1121 let result: () = this.TexStorage2D(arg0, arg1, arg2, arg3, arg4);
1122
1123 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1124 return true;
1125 })());
1126 result
1127}
1128
1129
1130static texStorage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1131
1132pub(crate) fn init_texStorage2D_methodinfo<D: DomTypes>() {
1133 texStorage2D_methodinfo.set(JSJitInfo {
1134 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1135 method: Some(texStorage2D::<D>)
1136 },
1137 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1138 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1139 },
1140 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1141 _bitfield_align_1: [],
1142 _bitfield_1: __BindgenBitfieldUnit::new(
1143 new_jsjitinfo_bitfield_1!(
1144 JSJitInfo_OpType::Method as u8,
1145 JSJitInfo_AliasSet::AliasEverything as u8,
1146 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1147 false,
1148 false,
1149 false,
1150 false,
1151 false,
1152 false,
1153 0,
1154 ).to_ne_bytes()
1155 ),
1156});
1157}
1158unsafe extern "C" fn texStorage3D<D: DomTypes>
1159(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1160 let mut result = false;
1161 wrap_panic(&mut || result = (|| {
1162 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1163 let this = &*(this as *const D::WebGL2RenderingContext);
1164 let args = &*args;
1165 let argc = args.argc_;
1166
1167 if argc < 6 {
1168 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.texStorage3D\".");
1169 return false;
1170 }
1171 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1172 Ok(ConversionResult::Success(value)) => value,
1173 Ok(ConversionResult::Failure(error)) => {
1174 throw_type_error(cx.raw_cx(), &error);
1175 return false;
1176
1177 }
1178 _ => {
1179 return false;
1180
1181 },
1182 }
1183 ;
1184 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1185 Ok(ConversionResult::Success(value)) => value,
1186 Ok(ConversionResult::Failure(error)) => {
1187 throw_type_error(cx.raw_cx(), &error);
1188 return false;
1189
1190 }
1191 _ => {
1192 return false;
1193
1194 },
1195 }
1196 ;
1197 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
1198 Ok(ConversionResult::Success(value)) => value,
1199 Ok(ConversionResult::Failure(error)) => {
1200 throw_type_error(cx.raw_cx(), &error);
1201 return false;
1202
1203 }
1204 _ => {
1205 return false;
1206
1207 },
1208 }
1209 ;
1210 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
1211 Ok(ConversionResult::Success(value)) => value,
1212 Ok(ConversionResult::Failure(error)) => {
1213 throw_type_error(cx.raw_cx(), &error);
1214 return false;
1215
1216 }
1217 _ => {
1218 return false;
1219
1220 },
1221 }
1222 ;
1223 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
1224 Ok(ConversionResult::Success(value)) => value,
1225 Ok(ConversionResult::Failure(error)) => {
1226 throw_type_error(cx.raw_cx(), &error);
1227 return false;
1228
1229 }
1230 _ => {
1231 return false;
1232
1233 },
1234 }
1235 ;
1236 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
1237 Ok(ConversionResult::Success(value)) => value,
1238 Ok(ConversionResult::Failure(error)) => {
1239 throw_type_error(cx.raw_cx(), &error);
1240 return false;
1241
1242 }
1243 _ => {
1244 return false;
1245
1246 },
1247 }
1248 ;
1249 let result: () = this.TexStorage3D(arg0, arg1, arg2, arg3, arg4, arg5);
1250
1251 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1252 return true;
1253 })());
1254 result
1255}
1256
1257
1258static texStorage3D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1259
1260pub(crate) fn init_texStorage3D_methodinfo<D: DomTypes>() {
1261 texStorage3D_methodinfo.set(JSJitInfo {
1262 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1263 method: Some(texStorage3D::<D>)
1264 },
1265 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1266 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1267 },
1268 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1269 _bitfield_align_1: [],
1270 _bitfield_1: __BindgenBitfieldUnit::new(
1271 new_jsjitinfo_bitfield_1!(
1272 JSJitInfo_OpType::Method as u8,
1273 JSJitInfo_AliasSet::AliasEverything as u8,
1274 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1275 false,
1276 false,
1277 false,
1278 false,
1279 false,
1280 false,
1281 0,
1282 ).to_ne_bytes()
1283 ),
1284});
1285}
1286unsafe extern "C" fn texImage3D<D: DomTypes>
1287(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1288 let mut result = false;
1289 wrap_panic(&mut || result = (|| {
1290 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1291 let this = &*(this as *const D::WebGL2RenderingContext);
1292 let args = &*args;
1293 let argc = args.argc_;
1294
1295 if argc < 10 {
1296 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.texImage3D\".");
1297 return false;
1298 }
1299 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1300 Ok(ConversionResult::Success(value)) => value,
1301 Ok(ConversionResult::Failure(error)) => {
1302 throw_type_error(cx.raw_cx(), &error);
1303 return false;
1304
1305 }
1306 _ => {
1307 return false;
1308
1309 },
1310 }
1311 ;
1312 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1313 Ok(ConversionResult::Success(value)) => value,
1314 Ok(ConversionResult::Failure(error)) => {
1315 throw_type_error(cx.raw_cx(), &error);
1316 return false;
1317
1318 }
1319 _ => {
1320 return false;
1321
1322 },
1323 }
1324 ;
1325 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
1326 Ok(ConversionResult::Success(value)) => value,
1327 Ok(ConversionResult::Failure(error)) => {
1328 throw_type_error(cx.raw_cx(), &error);
1329 return false;
1330
1331 }
1332 _ => {
1333 return false;
1334
1335 },
1336 }
1337 ;
1338 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
1339 Ok(ConversionResult::Success(value)) => value,
1340 Ok(ConversionResult::Failure(error)) => {
1341 throw_type_error(cx.raw_cx(), &error);
1342 return false;
1343
1344 }
1345 _ => {
1346 return false;
1347
1348 },
1349 }
1350 ;
1351 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
1352 Ok(ConversionResult::Success(value)) => value,
1353 Ok(ConversionResult::Failure(error)) => {
1354 throw_type_error(cx.raw_cx(), &error);
1355 return false;
1356
1357 }
1358 _ => {
1359 return false;
1360
1361 },
1362 }
1363 ;
1364 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
1365 Ok(ConversionResult::Success(value)) => value,
1366 Ok(ConversionResult::Failure(error)) => {
1367 throw_type_error(cx.raw_cx(), &error);
1368 return false;
1369
1370 }
1371 _ => {
1372 return false;
1373
1374 },
1375 }
1376 ;
1377 let arg6: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
1378 Ok(ConversionResult::Success(value)) => value,
1379 Ok(ConversionResult::Failure(error)) => {
1380 throw_type_error(cx.raw_cx(), &error);
1381 return false;
1382
1383 }
1384 _ => {
1385 return false;
1386
1387 },
1388 }
1389 ;
1390 let arg7: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
1391 Ok(ConversionResult::Success(value)) => value,
1392 Ok(ConversionResult::Failure(error)) => {
1393 throw_type_error(cx.raw_cx(), &error);
1394 return false;
1395
1396 }
1397 _ => {
1398 return false;
1399
1400 },
1401 }
1402 ;
1403 let arg8: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(8)), ConversionBehavior::Default) {
1404 Ok(ConversionResult::Success(value)) => value,
1405 Ok(ConversionResult::Failure(error)) => {
1406 throw_type_error(cx.raw_cx(), &error);
1407 return false;
1408
1409 }
1410 _ => {
1411 return false;
1412
1413 },
1414 }
1415 ;
1416 let arg9: Option<typedarray::ArrayBufferView> = if HandleValue::from_raw(args.get(9)).get().is_object() {
1417 Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(9)).get().to_object()) {
1418 Ok(val) => val,
1419 Err(()) => {
1420 throw_type_error(cx.raw_cx(), "value is not a typed array.");
1421 return false;
1422
1423 }
1424 }
1425 )
1426 } else if HandleValue::from_raw(args.get(9)).get().is_null_or_undefined() {
1427 None
1428 } else {
1429 throw_type_error(cx.raw_cx(), "Value is not an object.");
1430 return false;
1431
1432 };
1433 auto_root!(&in(cx) let arg9 = arg9);
1434 let result: Result<(), Error> = this.TexImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1435 let result = match result {
1436 Ok(result) => result,
1437 Err(e) => {
1438 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1439 return false;
1440 },
1441 };
1442
1443 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1444 return true;
1445 })());
1446 result
1447}
1448
1449
1450static texImage3D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1451
1452pub(crate) fn init_texImage3D_methodinfo<D: DomTypes>() {
1453 texImage3D_methodinfo.set(JSJitInfo {
1454 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1455 method: Some(texImage3D::<D>)
1456 },
1457 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1458 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1459 },
1460 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1461 _bitfield_align_1: [],
1462 _bitfield_1: __BindgenBitfieldUnit::new(
1463 new_jsjitinfo_bitfield_1!(
1464 JSJitInfo_OpType::Method as u8,
1465 JSJitInfo_AliasSet::AliasEverything as u8,
1466 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1467 false,
1468 false,
1469 false,
1470 false,
1471 false,
1472 false,
1473 0,
1474 ).to_ne_bytes()
1475 ),
1476});
1477}
1478unsafe extern "C" fn getFragDataLocation<D: DomTypes>
1479(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1480 let mut result = false;
1481 wrap_panic(&mut || result = (|| {
1482 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1483 let this = &*(this as *const D::WebGL2RenderingContext);
1484 let args = &*args;
1485 let argc = args.argc_;
1486
1487 if argc < 2 {
1488 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getFragDataLocation\".");
1489 return false;
1490 }
1491 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1492 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1493 Ok(val) => val,
1494 Err(()) => {
1495 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
1496 return false;
1497
1498 }
1499 }
1500
1501 } else {
1502 throw_type_error(cx.raw_cx(), "Value is not an object.");
1503 return false;
1504
1505 };
1506 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
1507 Ok(ConversionResult::Success(value)) => value,
1508 Ok(ConversionResult::Failure(error)) => {
1509 throw_type_error(cx.raw_cx(), &error);
1510 return false;
1511
1512 }
1513 _ => {
1514 return false;
1515
1516 },
1517 }
1518 ;
1519 let result: i32 = this.GetFragDataLocation(&arg0, arg1);
1520
1521 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1522 return true;
1523 })());
1524 result
1525}
1526
1527
1528static getFragDataLocation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1529
1530pub(crate) fn init_getFragDataLocation_methodinfo<D: DomTypes>() {
1531 getFragDataLocation_methodinfo.set(JSJitInfo {
1532 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1533 method: Some(getFragDataLocation::<D>)
1534 },
1535 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1536 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1537 },
1538 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1539 _bitfield_align_1: [],
1540 _bitfield_1: __BindgenBitfieldUnit::new(
1541 new_jsjitinfo_bitfield_1!(
1542 JSJitInfo_OpType::Method as u8,
1543 JSJitInfo_AliasSet::AliasEverything as u8,
1544 JSValueType::JSVAL_TYPE_INT32 as u8,
1545 false,
1546 false,
1547 false,
1548 false,
1549 false,
1550 false,
1551 0,
1552 ).to_ne_bytes()
1553 ),
1554});
1555}
1556unsafe extern "C" fn uniform1ui<D: DomTypes>
1557(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1558 let mut result = false;
1559 wrap_panic(&mut || result = (|| {
1560 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1561 let this = &*(this as *const D::WebGL2RenderingContext);
1562 let args = &*args;
1563 let argc = args.argc_;
1564
1565 if argc < 2 {
1566 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform1ui\".");
1567 return false;
1568 }
1569 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1570 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1571 Ok(val) => val,
1572 Err(()) => {
1573 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
1574 return false;
1575
1576 }
1577 }
1578 )
1579 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
1580 None
1581 } else {
1582 throw_type_error(cx.raw_cx(), "Value is not an object.");
1583 return false;
1584
1585 };
1586 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1587 Ok(ConversionResult::Success(value)) => value,
1588 Ok(ConversionResult::Failure(error)) => {
1589 throw_type_error(cx.raw_cx(), &error);
1590 return false;
1591
1592 }
1593 _ => {
1594 return false;
1595
1596 },
1597 }
1598 ;
1599 let result: () = this.Uniform1ui(arg0.as_deref(), arg1);
1600
1601 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1602 return true;
1603 })());
1604 result
1605}
1606
1607
1608static uniform1ui_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1609
1610pub(crate) fn init_uniform1ui_methodinfo<D: DomTypes>() {
1611 uniform1ui_methodinfo.set(JSJitInfo {
1612 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1613 method: Some(uniform1ui::<D>)
1614 },
1615 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1616 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1617 },
1618 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1619 _bitfield_align_1: [],
1620 _bitfield_1: __BindgenBitfieldUnit::new(
1621 new_jsjitinfo_bitfield_1!(
1622 JSJitInfo_OpType::Method as u8,
1623 JSJitInfo_AliasSet::AliasEverything as u8,
1624 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1625 false,
1626 false,
1627 false,
1628 false,
1629 false,
1630 false,
1631 0,
1632 ).to_ne_bytes()
1633 ),
1634});
1635}
1636unsafe extern "C" fn uniform2ui<D: DomTypes>
1637(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1638 let mut result = false;
1639 wrap_panic(&mut || result = (|| {
1640 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1641 let this = &*(this as *const D::WebGL2RenderingContext);
1642 let args = &*args;
1643 let argc = args.argc_;
1644
1645 if argc < 3 {
1646 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform2ui\".");
1647 return false;
1648 }
1649 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1650 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1651 Ok(val) => val,
1652 Err(()) => {
1653 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
1654 return false;
1655
1656 }
1657 }
1658 )
1659 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
1660 None
1661 } else {
1662 throw_type_error(cx.raw_cx(), "Value is not an object.");
1663 return false;
1664
1665 };
1666 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1667 Ok(ConversionResult::Success(value)) => value,
1668 Ok(ConversionResult::Failure(error)) => {
1669 throw_type_error(cx.raw_cx(), &error);
1670 return false;
1671
1672 }
1673 _ => {
1674 return false;
1675
1676 },
1677 }
1678 ;
1679 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
1680 Ok(ConversionResult::Success(value)) => value,
1681 Ok(ConversionResult::Failure(error)) => {
1682 throw_type_error(cx.raw_cx(), &error);
1683 return false;
1684
1685 }
1686 _ => {
1687 return false;
1688
1689 },
1690 }
1691 ;
1692 let result: () = this.Uniform2ui(arg0.as_deref(), arg1, arg2);
1693
1694 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1695 return true;
1696 })());
1697 result
1698}
1699
1700
1701static uniform2ui_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1702
1703pub(crate) fn init_uniform2ui_methodinfo<D: DomTypes>() {
1704 uniform2ui_methodinfo.set(JSJitInfo {
1705 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1706 method: Some(uniform2ui::<D>)
1707 },
1708 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1709 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1710 },
1711 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1712 _bitfield_align_1: [],
1713 _bitfield_1: __BindgenBitfieldUnit::new(
1714 new_jsjitinfo_bitfield_1!(
1715 JSJitInfo_OpType::Method as u8,
1716 JSJitInfo_AliasSet::AliasEverything as u8,
1717 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1718 false,
1719 false,
1720 false,
1721 false,
1722 false,
1723 false,
1724 0,
1725 ).to_ne_bytes()
1726 ),
1727});
1728}
1729unsafe extern "C" fn uniform3ui<D: DomTypes>
1730(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1731 let mut result = false;
1732 wrap_panic(&mut || result = (|| {
1733 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1734 let this = &*(this as *const D::WebGL2RenderingContext);
1735 let args = &*args;
1736 let argc = args.argc_;
1737
1738 if argc < 4 {
1739 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform3ui\".");
1740 return false;
1741 }
1742 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1743 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1744 Ok(val) => val,
1745 Err(()) => {
1746 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
1747 return false;
1748
1749 }
1750 }
1751 )
1752 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
1753 None
1754 } else {
1755 throw_type_error(cx.raw_cx(), "Value is not an object.");
1756 return false;
1757
1758 };
1759 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1760 Ok(ConversionResult::Success(value)) => value,
1761 Ok(ConversionResult::Failure(error)) => {
1762 throw_type_error(cx.raw_cx(), &error);
1763 return false;
1764
1765 }
1766 _ => {
1767 return false;
1768
1769 },
1770 }
1771 ;
1772 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
1773 Ok(ConversionResult::Success(value)) => value,
1774 Ok(ConversionResult::Failure(error)) => {
1775 throw_type_error(cx.raw_cx(), &error);
1776 return false;
1777
1778 }
1779 _ => {
1780 return false;
1781
1782 },
1783 }
1784 ;
1785 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
1786 Ok(ConversionResult::Success(value)) => value,
1787 Ok(ConversionResult::Failure(error)) => {
1788 throw_type_error(cx.raw_cx(), &error);
1789 return false;
1790
1791 }
1792 _ => {
1793 return false;
1794
1795 },
1796 }
1797 ;
1798 let result: () = this.Uniform3ui(arg0.as_deref(), arg1, arg2, arg3);
1799
1800 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1801 return true;
1802 })());
1803 result
1804}
1805
1806
1807static uniform3ui_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1808
1809pub(crate) fn init_uniform3ui_methodinfo<D: DomTypes>() {
1810 uniform3ui_methodinfo.set(JSJitInfo {
1811 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1812 method: Some(uniform3ui::<D>)
1813 },
1814 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1815 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1816 },
1817 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1818 _bitfield_align_1: [],
1819 _bitfield_1: __BindgenBitfieldUnit::new(
1820 new_jsjitinfo_bitfield_1!(
1821 JSJitInfo_OpType::Method as u8,
1822 JSJitInfo_AliasSet::AliasEverything as u8,
1823 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1824 false,
1825 false,
1826 false,
1827 false,
1828 false,
1829 false,
1830 0,
1831 ).to_ne_bytes()
1832 ),
1833});
1834}
1835unsafe extern "C" fn uniform4ui<D: DomTypes>
1836(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1837 let mut result = false;
1838 wrap_panic(&mut || result = (|| {
1839 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1840 let this = &*(this as *const D::WebGL2RenderingContext);
1841 let args = &*args;
1842 let argc = args.argc_;
1843
1844 if argc < 5 {
1845 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform4ui\".");
1846 return false;
1847 }
1848 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1849 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1850 Ok(val) => val,
1851 Err(()) => {
1852 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
1853 return false;
1854
1855 }
1856 }
1857 )
1858 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
1859 None
1860 } else {
1861 throw_type_error(cx.raw_cx(), "Value is not an object.");
1862 return false;
1863
1864 };
1865 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1866 Ok(ConversionResult::Success(value)) => value,
1867 Ok(ConversionResult::Failure(error)) => {
1868 throw_type_error(cx.raw_cx(), &error);
1869 return false;
1870
1871 }
1872 _ => {
1873 return false;
1874
1875 },
1876 }
1877 ;
1878 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
1879 Ok(ConversionResult::Success(value)) => value,
1880 Ok(ConversionResult::Failure(error)) => {
1881 throw_type_error(cx.raw_cx(), &error);
1882 return false;
1883
1884 }
1885 _ => {
1886 return false;
1887
1888 },
1889 }
1890 ;
1891 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
1892 Ok(ConversionResult::Success(value)) => value,
1893 Ok(ConversionResult::Failure(error)) => {
1894 throw_type_error(cx.raw_cx(), &error);
1895 return false;
1896
1897 }
1898 _ => {
1899 return false;
1900
1901 },
1902 }
1903 ;
1904 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
1905 Ok(ConversionResult::Success(value)) => value,
1906 Ok(ConversionResult::Failure(error)) => {
1907 throw_type_error(cx.raw_cx(), &error);
1908 return false;
1909
1910 }
1911 _ => {
1912 return false;
1913
1914 },
1915 }
1916 ;
1917 let result: () = this.Uniform4ui(arg0.as_deref(), arg1, arg2, arg3, arg4);
1918
1919 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1920 return true;
1921 })());
1922 result
1923}
1924
1925
1926static uniform4ui_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1927
1928pub(crate) fn init_uniform4ui_methodinfo<D: DomTypes>() {
1929 uniform4ui_methodinfo.set(JSJitInfo {
1930 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1931 method: Some(uniform4ui::<D>)
1932 },
1933 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1934 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
1935 },
1936 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1937 _bitfield_align_1: [],
1938 _bitfield_1: __BindgenBitfieldUnit::new(
1939 new_jsjitinfo_bitfield_1!(
1940 JSJitInfo_OpType::Method as u8,
1941 JSJitInfo_AliasSet::AliasEverything as u8,
1942 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1943 false,
1944 false,
1945 false,
1946 false,
1947 false,
1948 false,
1949 0,
1950 ).to_ne_bytes()
1951 ),
1952});
1953}
1954unsafe extern "C" fn uniform1uiv<D: DomTypes>
1955(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1956 let mut result = false;
1957 wrap_panic(&mut || result = (|| {
1958 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1959 let this = &*(this as *const D::WebGL2RenderingContext);
1960 let args = &*args;
1961 let argc = args.argc_;
1962
1963 if argc < 2 {
1964 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform1uiv\".");
1965 return false;
1966 }
1967 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
1968 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
1969 Ok(val) => val,
1970 Err(()) => {
1971 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
1972 return false;
1973
1974 }
1975 }
1976 )
1977 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
1978 None
1979 } else {
1980 throw_type_error(cx.raw_cx(), "Value is not an object.");
1981 return false;
1982
1983 };
1984 let arg1: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1985 Ok(ConversionResult::Success(value)) => value,
1986 Ok(ConversionResult::Failure(error)) => {
1987 throw_type_error(cx.raw_cx(), &error);
1988 return false;
1989
1990 }
1991 _ => {
1992 return false;
1993
1994 },
1995 }
1996 ;
1997 let arg2: u32 = if args.get(2).is_undefined() {
1998 0
1999 } else {
2000 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
2001 Ok(ConversionResult::Success(value)) => value,
2002 Ok(ConversionResult::Failure(error)) => {
2003 throw_type_error(cx.raw_cx(), &error);
2004 return false;
2005
2006 }
2007 _ => {
2008 return false;
2009
2010 },
2011 }
2012
2013 };
2014 let arg3: u32 = if args.get(3).is_undefined() {
2015 0
2016 } else {
2017 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2018 Ok(ConversionResult::Success(value)) => value,
2019 Ok(ConversionResult::Failure(error)) => {
2020 throw_type_error(cx.raw_cx(), &error);
2021 return false;
2022
2023 }
2024 _ => {
2025 return false;
2026
2027 },
2028 }
2029
2030 };
2031 let result: () = this.Uniform1uiv(arg0.as_deref(), arg1, arg2, arg3);
2032
2033 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2034 return true;
2035 })());
2036 result
2037}
2038
2039
2040static uniform1uiv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2041
2042pub(crate) fn init_uniform1uiv_methodinfo<D: DomTypes>() {
2043 uniform1uiv_methodinfo.set(JSJitInfo {
2044 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2045 method: Some(uniform1uiv::<D>)
2046 },
2047 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2048 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
2049 },
2050 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2051 _bitfield_align_1: [],
2052 _bitfield_1: __BindgenBitfieldUnit::new(
2053 new_jsjitinfo_bitfield_1!(
2054 JSJitInfo_OpType::Method as u8,
2055 JSJitInfo_AliasSet::AliasEverything as u8,
2056 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2057 false,
2058 false,
2059 false,
2060 false,
2061 false,
2062 false,
2063 0,
2064 ).to_ne_bytes()
2065 ),
2066});
2067}
2068unsafe extern "C" fn uniform2uiv<D: DomTypes>
2069(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2070 let mut result = false;
2071 wrap_panic(&mut || result = (|| {
2072 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2073 let this = &*(this as *const D::WebGL2RenderingContext);
2074 let args = &*args;
2075 let argc = args.argc_;
2076
2077 if argc < 2 {
2078 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform2uiv\".");
2079 return false;
2080 }
2081 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2082 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2083 Ok(val) => val,
2084 Err(()) => {
2085 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
2086 return false;
2087
2088 }
2089 }
2090 )
2091 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2092 None
2093 } else {
2094 throw_type_error(cx.raw_cx(), "Value is not an object.");
2095 return false;
2096
2097 };
2098 let arg1: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2099 Ok(ConversionResult::Success(value)) => value,
2100 Ok(ConversionResult::Failure(error)) => {
2101 throw_type_error(cx.raw_cx(), &error);
2102 return false;
2103
2104 }
2105 _ => {
2106 return false;
2107
2108 },
2109 }
2110 ;
2111 let arg2: u32 = if args.get(2).is_undefined() {
2112 0
2113 } else {
2114 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
2115 Ok(ConversionResult::Success(value)) => value,
2116 Ok(ConversionResult::Failure(error)) => {
2117 throw_type_error(cx.raw_cx(), &error);
2118 return false;
2119
2120 }
2121 _ => {
2122 return false;
2123
2124 },
2125 }
2126
2127 };
2128 let arg3: u32 = if args.get(3).is_undefined() {
2129 0
2130 } else {
2131 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2132 Ok(ConversionResult::Success(value)) => value,
2133 Ok(ConversionResult::Failure(error)) => {
2134 throw_type_error(cx.raw_cx(), &error);
2135 return false;
2136
2137 }
2138 _ => {
2139 return false;
2140
2141 },
2142 }
2143
2144 };
2145 let result: () = this.Uniform2uiv(arg0.as_deref(), arg1, arg2, arg3);
2146
2147 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2148 return true;
2149 })());
2150 result
2151}
2152
2153
2154static uniform2uiv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2155
2156pub(crate) fn init_uniform2uiv_methodinfo<D: DomTypes>() {
2157 uniform2uiv_methodinfo.set(JSJitInfo {
2158 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2159 method: Some(uniform2uiv::<D>)
2160 },
2161 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2162 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
2163 },
2164 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2165 _bitfield_align_1: [],
2166 _bitfield_1: __BindgenBitfieldUnit::new(
2167 new_jsjitinfo_bitfield_1!(
2168 JSJitInfo_OpType::Method as u8,
2169 JSJitInfo_AliasSet::AliasEverything as u8,
2170 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2171 false,
2172 false,
2173 false,
2174 false,
2175 false,
2176 false,
2177 0,
2178 ).to_ne_bytes()
2179 ),
2180});
2181}
2182unsafe extern "C" fn uniform3uiv<D: DomTypes>
2183(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2184 let mut result = false;
2185 wrap_panic(&mut || result = (|| {
2186 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2187 let this = &*(this as *const D::WebGL2RenderingContext);
2188 let args = &*args;
2189 let argc = args.argc_;
2190
2191 if argc < 2 {
2192 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform3uiv\".");
2193 return false;
2194 }
2195 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2196 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2197 Ok(val) => val,
2198 Err(()) => {
2199 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
2200 return false;
2201
2202 }
2203 }
2204 )
2205 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2206 None
2207 } else {
2208 throw_type_error(cx.raw_cx(), "Value is not an object.");
2209 return false;
2210
2211 };
2212 let arg1: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2213 Ok(ConversionResult::Success(value)) => value,
2214 Ok(ConversionResult::Failure(error)) => {
2215 throw_type_error(cx.raw_cx(), &error);
2216 return false;
2217
2218 }
2219 _ => {
2220 return false;
2221
2222 },
2223 }
2224 ;
2225 let arg2: u32 = if args.get(2).is_undefined() {
2226 0
2227 } else {
2228 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
2229 Ok(ConversionResult::Success(value)) => value,
2230 Ok(ConversionResult::Failure(error)) => {
2231 throw_type_error(cx.raw_cx(), &error);
2232 return false;
2233
2234 }
2235 _ => {
2236 return false;
2237
2238 },
2239 }
2240
2241 };
2242 let arg3: u32 = if args.get(3).is_undefined() {
2243 0
2244 } else {
2245 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2246 Ok(ConversionResult::Success(value)) => value,
2247 Ok(ConversionResult::Failure(error)) => {
2248 throw_type_error(cx.raw_cx(), &error);
2249 return false;
2250
2251 }
2252 _ => {
2253 return false;
2254
2255 },
2256 }
2257
2258 };
2259 let result: () = this.Uniform3uiv(arg0.as_deref(), arg1, arg2, arg3);
2260
2261 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2262 return true;
2263 })());
2264 result
2265}
2266
2267
2268static uniform3uiv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2269
2270pub(crate) fn init_uniform3uiv_methodinfo<D: DomTypes>() {
2271 uniform3uiv_methodinfo.set(JSJitInfo {
2272 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2273 method: Some(uniform3uiv::<D>)
2274 },
2275 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2276 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
2277 },
2278 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2279 _bitfield_align_1: [],
2280 _bitfield_1: __BindgenBitfieldUnit::new(
2281 new_jsjitinfo_bitfield_1!(
2282 JSJitInfo_OpType::Method as u8,
2283 JSJitInfo_AliasSet::AliasEverything as u8,
2284 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2285 false,
2286 false,
2287 false,
2288 false,
2289 false,
2290 false,
2291 0,
2292 ).to_ne_bytes()
2293 ),
2294});
2295}
2296unsafe extern "C" fn uniform4uiv<D: DomTypes>
2297(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2298 let mut result = false;
2299 wrap_panic(&mut || result = (|| {
2300 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2301 let this = &*(this as *const D::WebGL2RenderingContext);
2302 let args = &*args;
2303 let argc = args.argc_;
2304
2305 if argc < 2 {
2306 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform4uiv\".");
2307 return false;
2308 }
2309 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2310 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2311 Ok(val) => val,
2312 Err(()) => {
2313 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
2314 return false;
2315
2316 }
2317 }
2318 )
2319 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2320 None
2321 } else {
2322 throw_type_error(cx.raw_cx(), "Value is not an object.");
2323 return false;
2324
2325 };
2326 let arg1: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2327 Ok(ConversionResult::Success(value)) => value,
2328 Ok(ConversionResult::Failure(error)) => {
2329 throw_type_error(cx.raw_cx(), &error);
2330 return false;
2331
2332 }
2333 _ => {
2334 return false;
2335
2336 },
2337 }
2338 ;
2339 let arg2: u32 = if args.get(2).is_undefined() {
2340 0
2341 } else {
2342 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
2343 Ok(ConversionResult::Success(value)) => value,
2344 Ok(ConversionResult::Failure(error)) => {
2345 throw_type_error(cx.raw_cx(), &error);
2346 return false;
2347
2348 }
2349 _ => {
2350 return false;
2351
2352 },
2353 }
2354
2355 };
2356 let arg3: u32 = if args.get(3).is_undefined() {
2357 0
2358 } else {
2359 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2360 Ok(ConversionResult::Success(value)) => value,
2361 Ok(ConversionResult::Failure(error)) => {
2362 throw_type_error(cx.raw_cx(), &error);
2363 return false;
2364
2365 }
2366 _ => {
2367 return false;
2368
2369 },
2370 }
2371
2372 };
2373 let result: () = this.Uniform4uiv(arg0.as_deref(), arg1, arg2, arg3);
2374
2375 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2376 return true;
2377 })());
2378 result
2379}
2380
2381
2382static uniform4uiv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2383
2384pub(crate) fn init_uniform4uiv_methodinfo<D: DomTypes>() {
2385 uniform4uiv_methodinfo.set(JSJitInfo {
2386 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2387 method: Some(uniform4uiv::<D>)
2388 },
2389 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2390 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
2391 },
2392 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2393 _bitfield_align_1: [],
2394 _bitfield_1: __BindgenBitfieldUnit::new(
2395 new_jsjitinfo_bitfield_1!(
2396 JSJitInfo_OpType::Method as u8,
2397 JSJitInfo_AliasSet::AliasEverything as u8,
2398 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2399 false,
2400 false,
2401 false,
2402 false,
2403 false,
2404 false,
2405 0,
2406 ).to_ne_bytes()
2407 ),
2408});
2409}
2410unsafe extern "C" fn uniformMatrix3x2fv<D: DomTypes>
2411(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2412 let mut result = false;
2413 wrap_panic(&mut || result = (|| {
2414 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2415 let this = &*(this as *const D::WebGL2RenderingContext);
2416 let args = &*args;
2417 let argc = args.argc_;
2418
2419 if argc < 3 {
2420 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix3x2fv\".");
2421 return false;
2422 }
2423 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2424 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2425 Ok(val) => val,
2426 Err(()) => {
2427 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
2428 return false;
2429
2430 }
2431 }
2432 )
2433 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2434 None
2435 } else {
2436 throw_type_error(cx.raw_cx(), "Value is not an object.");
2437 return false;
2438
2439 };
2440 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2441 Ok(ConversionResult::Success(value)) => value,
2442 Ok(ConversionResult::Failure(error)) => {
2443 throw_type_error(cx.raw_cx(), &error);
2444 return false;
2445
2446 }
2447 _ => {
2448 return false;
2449
2450 },
2451 }
2452 ;
2453 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
2454 Ok(ConversionResult::Success(value)) => value,
2455 Ok(ConversionResult::Failure(error)) => {
2456 throw_type_error(cx.raw_cx(), &error);
2457 return false;
2458
2459 }
2460 _ => {
2461 return false;
2462
2463 },
2464 }
2465 ;
2466 let arg3: u32 = if args.get(3).is_undefined() {
2467 0
2468 } else {
2469 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2470 Ok(ConversionResult::Success(value)) => value,
2471 Ok(ConversionResult::Failure(error)) => {
2472 throw_type_error(cx.raw_cx(), &error);
2473 return false;
2474
2475 }
2476 _ => {
2477 return false;
2478
2479 },
2480 }
2481
2482 };
2483 let arg4: u32 = if args.get(4).is_undefined() {
2484 0
2485 } else {
2486 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
2487 Ok(ConversionResult::Success(value)) => value,
2488 Ok(ConversionResult::Failure(error)) => {
2489 throw_type_error(cx.raw_cx(), &error);
2490 return false;
2491
2492 }
2493 _ => {
2494 return false;
2495
2496 },
2497 }
2498
2499 };
2500 let result: () = this.UniformMatrix3x2fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
2501
2502 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2503 return true;
2504 })());
2505 result
2506}
2507
2508
2509static uniformMatrix3x2fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2510
2511pub(crate) fn init_uniformMatrix3x2fv_methodinfo<D: DomTypes>() {
2512 uniformMatrix3x2fv_methodinfo.set(JSJitInfo {
2513 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2514 method: Some(uniformMatrix3x2fv::<D>)
2515 },
2516 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2517 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
2518 },
2519 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2520 _bitfield_align_1: [],
2521 _bitfield_1: __BindgenBitfieldUnit::new(
2522 new_jsjitinfo_bitfield_1!(
2523 JSJitInfo_OpType::Method as u8,
2524 JSJitInfo_AliasSet::AliasEverything as u8,
2525 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2526 false,
2527 false,
2528 false,
2529 false,
2530 false,
2531 false,
2532 0,
2533 ).to_ne_bytes()
2534 ),
2535});
2536}
2537unsafe extern "C" fn uniformMatrix4x2fv<D: DomTypes>
2538(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2539 let mut result = false;
2540 wrap_panic(&mut || result = (|| {
2541 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2542 let this = &*(this as *const D::WebGL2RenderingContext);
2543 let args = &*args;
2544 let argc = args.argc_;
2545
2546 if argc < 3 {
2547 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix4x2fv\".");
2548 return false;
2549 }
2550 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2551 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2552 Ok(val) => val,
2553 Err(()) => {
2554 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
2555 return false;
2556
2557 }
2558 }
2559 )
2560 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2561 None
2562 } else {
2563 throw_type_error(cx.raw_cx(), "Value is not an object.");
2564 return false;
2565
2566 };
2567 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2568 Ok(ConversionResult::Success(value)) => value,
2569 Ok(ConversionResult::Failure(error)) => {
2570 throw_type_error(cx.raw_cx(), &error);
2571 return false;
2572
2573 }
2574 _ => {
2575 return false;
2576
2577 },
2578 }
2579 ;
2580 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
2581 Ok(ConversionResult::Success(value)) => value,
2582 Ok(ConversionResult::Failure(error)) => {
2583 throw_type_error(cx.raw_cx(), &error);
2584 return false;
2585
2586 }
2587 _ => {
2588 return false;
2589
2590 },
2591 }
2592 ;
2593 let arg3: u32 = if args.get(3).is_undefined() {
2594 0
2595 } else {
2596 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2597 Ok(ConversionResult::Success(value)) => value,
2598 Ok(ConversionResult::Failure(error)) => {
2599 throw_type_error(cx.raw_cx(), &error);
2600 return false;
2601
2602 }
2603 _ => {
2604 return false;
2605
2606 },
2607 }
2608
2609 };
2610 let arg4: u32 = if args.get(4).is_undefined() {
2611 0
2612 } else {
2613 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
2614 Ok(ConversionResult::Success(value)) => value,
2615 Ok(ConversionResult::Failure(error)) => {
2616 throw_type_error(cx.raw_cx(), &error);
2617 return false;
2618
2619 }
2620 _ => {
2621 return false;
2622
2623 },
2624 }
2625
2626 };
2627 let result: () = this.UniformMatrix4x2fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
2628
2629 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2630 return true;
2631 })());
2632 result
2633}
2634
2635
2636static uniformMatrix4x2fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2637
2638pub(crate) fn init_uniformMatrix4x2fv_methodinfo<D: DomTypes>() {
2639 uniformMatrix4x2fv_methodinfo.set(JSJitInfo {
2640 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2641 method: Some(uniformMatrix4x2fv::<D>)
2642 },
2643 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2644 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
2645 },
2646 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2647 _bitfield_align_1: [],
2648 _bitfield_1: __BindgenBitfieldUnit::new(
2649 new_jsjitinfo_bitfield_1!(
2650 JSJitInfo_OpType::Method as u8,
2651 JSJitInfo_AliasSet::AliasEverything as u8,
2652 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2653 false,
2654 false,
2655 false,
2656 false,
2657 false,
2658 false,
2659 0,
2660 ).to_ne_bytes()
2661 ),
2662});
2663}
2664unsafe extern "C" fn uniformMatrix2x3fv<D: DomTypes>
2665(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2666 let mut result = false;
2667 wrap_panic(&mut || result = (|| {
2668 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2669 let this = &*(this as *const D::WebGL2RenderingContext);
2670 let args = &*args;
2671 let argc = args.argc_;
2672
2673 if argc < 3 {
2674 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix2x3fv\".");
2675 return false;
2676 }
2677 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2678 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2679 Ok(val) => val,
2680 Err(()) => {
2681 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
2682 return false;
2683
2684 }
2685 }
2686 )
2687 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2688 None
2689 } else {
2690 throw_type_error(cx.raw_cx(), "Value is not an object.");
2691 return false;
2692
2693 };
2694 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2695 Ok(ConversionResult::Success(value)) => value,
2696 Ok(ConversionResult::Failure(error)) => {
2697 throw_type_error(cx.raw_cx(), &error);
2698 return false;
2699
2700 }
2701 _ => {
2702 return false;
2703
2704 },
2705 }
2706 ;
2707 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
2708 Ok(ConversionResult::Success(value)) => value,
2709 Ok(ConversionResult::Failure(error)) => {
2710 throw_type_error(cx.raw_cx(), &error);
2711 return false;
2712
2713 }
2714 _ => {
2715 return false;
2716
2717 },
2718 }
2719 ;
2720 let arg3: u32 = if args.get(3).is_undefined() {
2721 0
2722 } else {
2723 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2724 Ok(ConversionResult::Success(value)) => value,
2725 Ok(ConversionResult::Failure(error)) => {
2726 throw_type_error(cx.raw_cx(), &error);
2727 return false;
2728
2729 }
2730 _ => {
2731 return false;
2732
2733 },
2734 }
2735
2736 };
2737 let arg4: u32 = if args.get(4).is_undefined() {
2738 0
2739 } else {
2740 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
2741 Ok(ConversionResult::Success(value)) => value,
2742 Ok(ConversionResult::Failure(error)) => {
2743 throw_type_error(cx.raw_cx(), &error);
2744 return false;
2745
2746 }
2747 _ => {
2748 return false;
2749
2750 },
2751 }
2752
2753 };
2754 let result: () = this.UniformMatrix2x3fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
2755
2756 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2757 return true;
2758 })());
2759 result
2760}
2761
2762
2763static uniformMatrix2x3fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2764
2765pub(crate) fn init_uniformMatrix2x3fv_methodinfo<D: DomTypes>() {
2766 uniformMatrix2x3fv_methodinfo.set(JSJitInfo {
2767 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2768 method: Some(uniformMatrix2x3fv::<D>)
2769 },
2770 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2771 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
2772 },
2773 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2774 _bitfield_align_1: [],
2775 _bitfield_1: __BindgenBitfieldUnit::new(
2776 new_jsjitinfo_bitfield_1!(
2777 JSJitInfo_OpType::Method as u8,
2778 JSJitInfo_AliasSet::AliasEverything as u8,
2779 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2780 false,
2781 false,
2782 false,
2783 false,
2784 false,
2785 false,
2786 0,
2787 ).to_ne_bytes()
2788 ),
2789});
2790}
2791unsafe extern "C" fn uniformMatrix4x3fv<D: DomTypes>
2792(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2793 let mut result = false;
2794 wrap_panic(&mut || result = (|| {
2795 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2796 let this = &*(this as *const D::WebGL2RenderingContext);
2797 let args = &*args;
2798 let argc = args.argc_;
2799
2800 if argc < 3 {
2801 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix4x3fv\".");
2802 return false;
2803 }
2804 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2805 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2806 Ok(val) => val,
2807 Err(()) => {
2808 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
2809 return false;
2810
2811 }
2812 }
2813 )
2814 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2815 None
2816 } else {
2817 throw_type_error(cx.raw_cx(), "Value is not an object.");
2818 return false;
2819
2820 };
2821 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2822 Ok(ConversionResult::Success(value)) => value,
2823 Ok(ConversionResult::Failure(error)) => {
2824 throw_type_error(cx.raw_cx(), &error);
2825 return false;
2826
2827 }
2828 _ => {
2829 return false;
2830
2831 },
2832 }
2833 ;
2834 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
2835 Ok(ConversionResult::Success(value)) => value,
2836 Ok(ConversionResult::Failure(error)) => {
2837 throw_type_error(cx.raw_cx(), &error);
2838 return false;
2839
2840 }
2841 _ => {
2842 return false;
2843
2844 },
2845 }
2846 ;
2847 let arg3: u32 = if args.get(3).is_undefined() {
2848 0
2849 } else {
2850 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2851 Ok(ConversionResult::Success(value)) => value,
2852 Ok(ConversionResult::Failure(error)) => {
2853 throw_type_error(cx.raw_cx(), &error);
2854 return false;
2855
2856 }
2857 _ => {
2858 return false;
2859
2860 },
2861 }
2862
2863 };
2864 let arg4: u32 = if args.get(4).is_undefined() {
2865 0
2866 } else {
2867 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
2868 Ok(ConversionResult::Success(value)) => value,
2869 Ok(ConversionResult::Failure(error)) => {
2870 throw_type_error(cx.raw_cx(), &error);
2871 return false;
2872
2873 }
2874 _ => {
2875 return false;
2876
2877 },
2878 }
2879
2880 };
2881 let result: () = this.UniformMatrix4x3fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
2882
2883 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2884 return true;
2885 })());
2886 result
2887}
2888
2889
2890static uniformMatrix4x3fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2891
2892pub(crate) fn init_uniformMatrix4x3fv_methodinfo<D: DomTypes>() {
2893 uniformMatrix4x3fv_methodinfo.set(JSJitInfo {
2894 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2895 method: Some(uniformMatrix4x3fv::<D>)
2896 },
2897 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2898 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
2899 },
2900 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2901 _bitfield_align_1: [],
2902 _bitfield_1: __BindgenBitfieldUnit::new(
2903 new_jsjitinfo_bitfield_1!(
2904 JSJitInfo_OpType::Method as u8,
2905 JSJitInfo_AliasSet::AliasEverything as u8,
2906 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2907 false,
2908 false,
2909 false,
2910 false,
2911 false,
2912 false,
2913 0,
2914 ).to_ne_bytes()
2915 ),
2916});
2917}
2918unsafe extern "C" fn uniformMatrix2x4fv<D: DomTypes>
2919(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2920 let mut result = false;
2921 wrap_panic(&mut || result = (|| {
2922 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2923 let this = &*(this as *const D::WebGL2RenderingContext);
2924 let args = &*args;
2925 let argc = args.argc_;
2926
2927 if argc < 3 {
2928 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix2x4fv\".");
2929 return false;
2930 }
2931 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2932 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2933 Ok(val) => val,
2934 Err(()) => {
2935 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
2936 return false;
2937
2938 }
2939 }
2940 )
2941 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2942 None
2943 } else {
2944 throw_type_error(cx.raw_cx(), "Value is not an object.");
2945 return false;
2946
2947 };
2948 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2949 Ok(ConversionResult::Success(value)) => value,
2950 Ok(ConversionResult::Failure(error)) => {
2951 throw_type_error(cx.raw_cx(), &error);
2952 return false;
2953
2954 }
2955 _ => {
2956 return false;
2957
2958 },
2959 }
2960 ;
2961 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
2962 Ok(ConversionResult::Success(value)) => value,
2963 Ok(ConversionResult::Failure(error)) => {
2964 throw_type_error(cx.raw_cx(), &error);
2965 return false;
2966
2967 }
2968 _ => {
2969 return false;
2970
2971 },
2972 }
2973 ;
2974 let arg3: u32 = if args.get(3).is_undefined() {
2975 0
2976 } else {
2977 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2978 Ok(ConversionResult::Success(value)) => value,
2979 Ok(ConversionResult::Failure(error)) => {
2980 throw_type_error(cx.raw_cx(), &error);
2981 return false;
2982
2983 }
2984 _ => {
2985 return false;
2986
2987 },
2988 }
2989
2990 };
2991 let arg4: u32 = if args.get(4).is_undefined() {
2992 0
2993 } else {
2994 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
2995 Ok(ConversionResult::Success(value)) => value,
2996 Ok(ConversionResult::Failure(error)) => {
2997 throw_type_error(cx.raw_cx(), &error);
2998 return false;
2999
3000 }
3001 _ => {
3002 return false;
3003
3004 },
3005 }
3006
3007 };
3008 let result: () = this.UniformMatrix2x4fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
3009
3010 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3011 return true;
3012 })());
3013 result
3014}
3015
3016
3017static uniformMatrix2x4fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3018
3019pub(crate) fn init_uniformMatrix2x4fv_methodinfo<D: DomTypes>() {
3020 uniformMatrix2x4fv_methodinfo.set(JSJitInfo {
3021 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3022 method: Some(uniformMatrix2x4fv::<D>)
3023 },
3024 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3025 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3026 },
3027 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3028 _bitfield_align_1: [],
3029 _bitfield_1: __BindgenBitfieldUnit::new(
3030 new_jsjitinfo_bitfield_1!(
3031 JSJitInfo_OpType::Method as u8,
3032 JSJitInfo_AliasSet::AliasEverything as u8,
3033 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3034 false,
3035 false,
3036 false,
3037 false,
3038 false,
3039 false,
3040 0,
3041 ).to_ne_bytes()
3042 ),
3043});
3044}
3045unsafe extern "C" fn uniformMatrix3x4fv<D: DomTypes>
3046(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3047 let mut result = false;
3048 wrap_panic(&mut || result = (|| {
3049 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3050 let this = &*(this as *const D::WebGL2RenderingContext);
3051 let args = &*args;
3052 let argc = args.argc_;
3053
3054 if argc < 3 {
3055 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix3x4fv\".");
3056 return false;
3057 }
3058 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
3059 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
3060 Ok(val) => val,
3061 Err(()) => {
3062 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
3063 return false;
3064
3065 }
3066 }
3067 )
3068 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
3069 None
3070 } else {
3071 throw_type_error(cx.raw_cx(), "Value is not an object.");
3072 return false;
3073
3074 };
3075 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
3076 Ok(ConversionResult::Success(value)) => value,
3077 Ok(ConversionResult::Failure(error)) => {
3078 throw_type_error(cx.raw_cx(), &error);
3079 return false;
3080
3081 }
3082 _ => {
3083 return false;
3084
3085 },
3086 }
3087 ;
3088 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
3089 Ok(ConversionResult::Success(value)) => value,
3090 Ok(ConversionResult::Failure(error)) => {
3091 throw_type_error(cx.raw_cx(), &error);
3092 return false;
3093
3094 }
3095 _ => {
3096 return false;
3097
3098 },
3099 }
3100 ;
3101 let arg3: u32 = if args.get(3).is_undefined() {
3102 0
3103 } else {
3104 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
3105 Ok(ConversionResult::Success(value)) => value,
3106 Ok(ConversionResult::Failure(error)) => {
3107 throw_type_error(cx.raw_cx(), &error);
3108 return false;
3109
3110 }
3111 _ => {
3112 return false;
3113
3114 },
3115 }
3116
3117 };
3118 let arg4: u32 = if args.get(4).is_undefined() {
3119 0
3120 } else {
3121 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
3122 Ok(ConversionResult::Success(value)) => value,
3123 Ok(ConversionResult::Failure(error)) => {
3124 throw_type_error(cx.raw_cx(), &error);
3125 return false;
3126
3127 }
3128 _ => {
3129 return false;
3130
3131 },
3132 }
3133
3134 };
3135 let result: () = this.UniformMatrix3x4fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
3136
3137 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3138 return true;
3139 })());
3140 result
3141}
3142
3143
3144static uniformMatrix3x4fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3145
3146pub(crate) fn init_uniformMatrix3x4fv_methodinfo<D: DomTypes>() {
3147 uniformMatrix3x4fv_methodinfo.set(JSJitInfo {
3148 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3149 method: Some(uniformMatrix3x4fv::<D>)
3150 },
3151 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3152 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3153 },
3154 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3155 _bitfield_align_1: [],
3156 _bitfield_1: __BindgenBitfieldUnit::new(
3157 new_jsjitinfo_bitfield_1!(
3158 JSJitInfo_OpType::Method as u8,
3159 JSJitInfo_AliasSet::AliasEverything as u8,
3160 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3161 false,
3162 false,
3163 false,
3164 false,
3165 false,
3166 false,
3167 0,
3168 ).to_ne_bytes()
3169 ),
3170});
3171}
3172unsafe extern "C" fn vertexAttribI4i<D: DomTypes>
3173(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3174 let mut result = false;
3175 wrap_panic(&mut || result = (|| {
3176 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3177 let this = &*(this as *const D::WebGL2RenderingContext);
3178 let args = &*args;
3179 let argc = args.argc_;
3180
3181 if argc < 5 {
3182 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttribI4i\".");
3183 return false;
3184 }
3185 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3186 Ok(ConversionResult::Success(value)) => value,
3187 Ok(ConversionResult::Failure(error)) => {
3188 throw_type_error(cx.raw_cx(), &error);
3189 return false;
3190
3191 }
3192 _ => {
3193 return false;
3194
3195 },
3196 }
3197 ;
3198 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3199 Ok(ConversionResult::Success(value)) => value,
3200 Ok(ConversionResult::Failure(error)) => {
3201 throw_type_error(cx.raw_cx(), &error);
3202 return false;
3203
3204 }
3205 _ => {
3206 return false;
3207
3208 },
3209 }
3210 ;
3211 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
3212 Ok(ConversionResult::Success(value)) => value,
3213 Ok(ConversionResult::Failure(error)) => {
3214 throw_type_error(cx.raw_cx(), &error);
3215 return false;
3216
3217 }
3218 _ => {
3219 return false;
3220
3221 },
3222 }
3223 ;
3224 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
3225 Ok(ConversionResult::Success(value)) => value,
3226 Ok(ConversionResult::Failure(error)) => {
3227 throw_type_error(cx.raw_cx(), &error);
3228 return false;
3229
3230 }
3231 _ => {
3232 return false;
3233
3234 },
3235 }
3236 ;
3237 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
3238 Ok(ConversionResult::Success(value)) => value,
3239 Ok(ConversionResult::Failure(error)) => {
3240 throw_type_error(cx.raw_cx(), &error);
3241 return false;
3242
3243 }
3244 _ => {
3245 return false;
3246
3247 },
3248 }
3249 ;
3250 let result: () = this.VertexAttribI4i(arg0, arg1, arg2, arg3, arg4);
3251
3252 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3253 return true;
3254 })());
3255 result
3256}
3257
3258
3259static vertexAttribI4i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3260
3261pub(crate) fn init_vertexAttribI4i_methodinfo<D: DomTypes>() {
3262 vertexAttribI4i_methodinfo.set(JSJitInfo {
3263 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3264 method: Some(vertexAttribI4i::<D>)
3265 },
3266 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3267 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3268 },
3269 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3270 _bitfield_align_1: [],
3271 _bitfield_1: __BindgenBitfieldUnit::new(
3272 new_jsjitinfo_bitfield_1!(
3273 JSJitInfo_OpType::Method as u8,
3274 JSJitInfo_AliasSet::AliasEverything as u8,
3275 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3276 false,
3277 false,
3278 false,
3279 false,
3280 false,
3281 false,
3282 0,
3283 ).to_ne_bytes()
3284 ),
3285});
3286}
3287unsafe extern "C" fn vertexAttribI4iv<D: DomTypes>
3288(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3289 let mut result = false;
3290 wrap_panic(&mut || result = (|| {
3291 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3292 let this = &*(this as *const D::WebGL2RenderingContext);
3293 let args = &*args;
3294 let argc = args.argc_;
3295
3296 if argc < 2 {
3297 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttribI4iv\".");
3298 return false;
3299 }
3300 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3301 Ok(ConversionResult::Success(value)) => value,
3302 Ok(ConversionResult::Failure(error)) => {
3303 throw_type_error(cx.raw_cx(), &error);
3304 return false;
3305
3306 }
3307 _ => {
3308 return false;
3309
3310 },
3311 }
3312 ;
3313 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
3314 Ok(ConversionResult::Success(value)) => value,
3315 Ok(ConversionResult::Failure(error)) => {
3316 throw_type_error(cx.raw_cx(), &error);
3317 return false;
3318
3319 }
3320 _ => {
3321 return false;
3322
3323 },
3324 }
3325 ;
3326 let result: () = this.VertexAttribI4iv(arg0, arg1);
3327
3328 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3329 return true;
3330 })());
3331 result
3332}
3333
3334
3335static vertexAttribI4iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3336
3337pub(crate) fn init_vertexAttribI4iv_methodinfo<D: DomTypes>() {
3338 vertexAttribI4iv_methodinfo.set(JSJitInfo {
3339 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3340 method: Some(vertexAttribI4iv::<D>)
3341 },
3342 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3343 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3344 },
3345 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3346 _bitfield_align_1: [],
3347 _bitfield_1: __BindgenBitfieldUnit::new(
3348 new_jsjitinfo_bitfield_1!(
3349 JSJitInfo_OpType::Method as u8,
3350 JSJitInfo_AliasSet::AliasEverything as u8,
3351 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3352 false,
3353 false,
3354 false,
3355 false,
3356 false,
3357 false,
3358 0,
3359 ).to_ne_bytes()
3360 ),
3361});
3362}
3363unsafe extern "C" fn vertexAttribI4ui<D: DomTypes>
3364(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3365 let mut result = false;
3366 wrap_panic(&mut || result = (|| {
3367 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3368 let this = &*(this as *const D::WebGL2RenderingContext);
3369 let args = &*args;
3370 let argc = args.argc_;
3371
3372 if argc < 5 {
3373 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttribI4ui\".");
3374 return false;
3375 }
3376 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3377 Ok(ConversionResult::Success(value)) => value,
3378 Ok(ConversionResult::Failure(error)) => {
3379 throw_type_error(cx.raw_cx(), &error);
3380 return false;
3381
3382 }
3383 _ => {
3384 return false;
3385
3386 },
3387 }
3388 ;
3389 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3390 Ok(ConversionResult::Success(value)) => value,
3391 Ok(ConversionResult::Failure(error)) => {
3392 throw_type_error(cx.raw_cx(), &error);
3393 return false;
3394
3395 }
3396 _ => {
3397 return false;
3398
3399 },
3400 }
3401 ;
3402 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
3403 Ok(ConversionResult::Success(value)) => value,
3404 Ok(ConversionResult::Failure(error)) => {
3405 throw_type_error(cx.raw_cx(), &error);
3406 return false;
3407
3408 }
3409 _ => {
3410 return false;
3411
3412 },
3413 }
3414 ;
3415 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
3416 Ok(ConversionResult::Success(value)) => value,
3417 Ok(ConversionResult::Failure(error)) => {
3418 throw_type_error(cx.raw_cx(), &error);
3419 return false;
3420
3421 }
3422 _ => {
3423 return false;
3424
3425 },
3426 }
3427 ;
3428 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
3429 Ok(ConversionResult::Success(value)) => value,
3430 Ok(ConversionResult::Failure(error)) => {
3431 throw_type_error(cx.raw_cx(), &error);
3432 return false;
3433
3434 }
3435 _ => {
3436 return false;
3437
3438 },
3439 }
3440 ;
3441 let result: () = this.VertexAttribI4ui(arg0, arg1, arg2, arg3, arg4);
3442
3443 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3444 return true;
3445 })());
3446 result
3447}
3448
3449
3450static vertexAttribI4ui_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3451
3452pub(crate) fn init_vertexAttribI4ui_methodinfo<D: DomTypes>() {
3453 vertexAttribI4ui_methodinfo.set(JSJitInfo {
3454 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3455 method: Some(vertexAttribI4ui::<D>)
3456 },
3457 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3458 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3459 },
3460 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3461 _bitfield_align_1: [],
3462 _bitfield_1: __BindgenBitfieldUnit::new(
3463 new_jsjitinfo_bitfield_1!(
3464 JSJitInfo_OpType::Method as u8,
3465 JSJitInfo_AliasSet::AliasEverything as u8,
3466 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3467 false,
3468 false,
3469 false,
3470 false,
3471 false,
3472 false,
3473 0,
3474 ).to_ne_bytes()
3475 ),
3476});
3477}
3478unsafe extern "C" fn vertexAttribI4uiv<D: DomTypes>
3479(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3480 let mut result = false;
3481 wrap_panic(&mut || result = (|| {
3482 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3483 let this = &*(this as *const D::WebGL2RenderingContext);
3484 let args = &*args;
3485 let argc = args.argc_;
3486
3487 if argc < 2 {
3488 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttribI4uiv\".");
3489 return false;
3490 }
3491 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3492 Ok(ConversionResult::Success(value)) => value,
3493 Ok(ConversionResult::Failure(error)) => {
3494 throw_type_error(cx.raw_cx(), &error);
3495 return false;
3496
3497 }
3498 _ => {
3499 return false;
3500
3501 },
3502 }
3503 ;
3504 let arg1: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
3505 Ok(ConversionResult::Success(value)) => value,
3506 Ok(ConversionResult::Failure(error)) => {
3507 throw_type_error(cx.raw_cx(), &error);
3508 return false;
3509
3510 }
3511 _ => {
3512 return false;
3513
3514 },
3515 }
3516 ;
3517 let result: () = this.VertexAttribI4uiv(arg0, arg1);
3518
3519 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3520 return true;
3521 })());
3522 result
3523}
3524
3525
3526static vertexAttribI4uiv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3527
3528pub(crate) fn init_vertexAttribI4uiv_methodinfo<D: DomTypes>() {
3529 vertexAttribI4uiv_methodinfo.set(JSJitInfo {
3530 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3531 method: Some(vertexAttribI4uiv::<D>)
3532 },
3533 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3534 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3535 },
3536 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3537 _bitfield_align_1: [],
3538 _bitfield_1: __BindgenBitfieldUnit::new(
3539 new_jsjitinfo_bitfield_1!(
3540 JSJitInfo_OpType::Method as u8,
3541 JSJitInfo_AliasSet::AliasEverything as u8,
3542 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3543 false,
3544 false,
3545 false,
3546 false,
3547 false,
3548 false,
3549 0,
3550 ).to_ne_bytes()
3551 ),
3552});
3553}
3554unsafe extern "C" fn vertexAttribIPointer<D: DomTypes>
3555(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3556 let mut result = false;
3557 wrap_panic(&mut || result = (|| {
3558 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3559 let this = &*(this as *const D::WebGL2RenderingContext);
3560 let args = &*args;
3561 let argc = args.argc_;
3562
3563 if argc < 5 {
3564 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttribIPointer\".");
3565 return false;
3566 }
3567 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3568 Ok(ConversionResult::Success(value)) => value,
3569 Ok(ConversionResult::Failure(error)) => {
3570 throw_type_error(cx.raw_cx(), &error);
3571 return false;
3572
3573 }
3574 _ => {
3575 return false;
3576
3577 },
3578 }
3579 ;
3580 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3581 Ok(ConversionResult::Success(value)) => value,
3582 Ok(ConversionResult::Failure(error)) => {
3583 throw_type_error(cx.raw_cx(), &error);
3584 return false;
3585
3586 }
3587 _ => {
3588 return false;
3589
3590 },
3591 }
3592 ;
3593 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
3594 Ok(ConversionResult::Success(value)) => value,
3595 Ok(ConversionResult::Failure(error)) => {
3596 throw_type_error(cx.raw_cx(), &error);
3597 return false;
3598
3599 }
3600 _ => {
3601 return false;
3602
3603 },
3604 }
3605 ;
3606 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
3607 Ok(ConversionResult::Success(value)) => value,
3608 Ok(ConversionResult::Failure(error)) => {
3609 throw_type_error(cx.raw_cx(), &error);
3610 return false;
3611
3612 }
3613 _ => {
3614 return false;
3615
3616 },
3617 }
3618 ;
3619 let arg4: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
3620 Ok(ConversionResult::Success(value)) => value,
3621 Ok(ConversionResult::Failure(error)) => {
3622 throw_type_error(cx.raw_cx(), &error);
3623 return false;
3624
3625 }
3626 _ => {
3627 return false;
3628
3629 },
3630 }
3631 ;
3632 let result: () = this.VertexAttribIPointer(arg0, arg1, arg2, arg3, arg4);
3633
3634 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3635 return true;
3636 })());
3637 result
3638}
3639
3640
3641static vertexAttribIPointer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3642
3643pub(crate) fn init_vertexAttribIPointer_methodinfo<D: DomTypes>() {
3644 vertexAttribIPointer_methodinfo.set(JSJitInfo {
3645 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3646 method: Some(vertexAttribIPointer::<D>)
3647 },
3648 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3649 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3650 },
3651 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3652 _bitfield_align_1: [],
3653 _bitfield_1: __BindgenBitfieldUnit::new(
3654 new_jsjitinfo_bitfield_1!(
3655 JSJitInfo_OpType::Method as u8,
3656 JSJitInfo_AliasSet::AliasEverything as u8,
3657 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3658 false,
3659 false,
3660 false,
3661 false,
3662 false,
3663 false,
3664 0,
3665 ).to_ne_bytes()
3666 ),
3667});
3668}
3669unsafe extern "C" fn vertexAttribDivisor<D: DomTypes>
3670(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3671 let mut result = false;
3672 wrap_panic(&mut || result = (|| {
3673 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3674 let this = &*(this as *const D::WebGL2RenderingContext);
3675 let args = &*args;
3676 let argc = args.argc_;
3677
3678 if argc < 2 {
3679 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttribDivisor\".");
3680 return false;
3681 }
3682 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3683 Ok(ConversionResult::Success(value)) => value,
3684 Ok(ConversionResult::Failure(error)) => {
3685 throw_type_error(cx.raw_cx(), &error);
3686 return false;
3687
3688 }
3689 _ => {
3690 return false;
3691
3692 },
3693 }
3694 ;
3695 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3696 Ok(ConversionResult::Success(value)) => value,
3697 Ok(ConversionResult::Failure(error)) => {
3698 throw_type_error(cx.raw_cx(), &error);
3699 return false;
3700
3701 }
3702 _ => {
3703 return false;
3704
3705 },
3706 }
3707 ;
3708 let result: () = this.VertexAttribDivisor(arg0, arg1);
3709
3710 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3711 return true;
3712 })());
3713 result
3714}
3715
3716
3717static vertexAttribDivisor_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3718
3719pub(crate) fn init_vertexAttribDivisor_methodinfo<D: DomTypes>() {
3720 vertexAttribDivisor_methodinfo.set(JSJitInfo {
3721 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3722 method: Some(vertexAttribDivisor::<D>)
3723 },
3724 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3725 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3726 },
3727 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3728 _bitfield_align_1: [],
3729 _bitfield_1: __BindgenBitfieldUnit::new(
3730 new_jsjitinfo_bitfield_1!(
3731 JSJitInfo_OpType::Method as u8,
3732 JSJitInfo_AliasSet::AliasEverything as u8,
3733 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3734 false,
3735 false,
3736 false,
3737 false,
3738 false,
3739 false,
3740 0,
3741 ).to_ne_bytes()
3742 ),
3743});
3744}
3745unsafe extern "C" fn drawArraysInstanced<D: DomTypes>
3746(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3747 let mut result = false;
3748 wrap_panic(&mut || result = (|| {
3749 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3750 let this = &*(this as *const D::WebGL2RenderingContext);
3751 let args = &*args;
3752 let argc = args.argc_;
3753
3754 if argc < 4 {
3755 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.drawArraysInstanced\".");
3756 return false;
3757 }
3758 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3759 Ok(ConversionResult::Success(value)) => value,
3760 Ok(ConversionResult::Failure(error)) => {
3761 throw_type_error(cx.raw_cx(), &error);
3762 return false;
3763
3764 }
3765 _ => {
3766 return false;
3767
3768 },
3769 }
3770 ;
3771 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3772 Ok(ConversionResult::Success(value)) => value,
3773 Ok(ConversionResult::Failure(error)) => {
3774 throw_type_error(cx.raw_cx(), &error);
3775 return false;
3776
3777 }
3778 _ => {
3779 return false;
3780
3781 },
3782 }
3783 ;
3784 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
3785 Ok(ConversionResult::Success(value)) => value,
3786 Ok(ConversionResult::Failure(error)) => {
3787 throw_type_error(cx.raw_cx(), &error);
3788 return false;
3789
3790 }
3791 _ => {
3792 return false;
3793
3794 },
3795 }
3796 ;
3797 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
3798 Ok(ConversionResult::Success(value)) => value,
3799 Ok(ConversionResult::Failure(error)) => {
3800 throw_type_error(cx.raw_cx(), &error);
3801 return false;
3802
3803 }
3804 _ => {
3805 return false;
3806
3807 },
3808 }
3809 ;
3810 let result: () = this.DrawArraysInstanced(arg0, arg1, arg2, arg3);
3811
3812 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3813 return true;
3814 })());
3815 result
3816}
3817
3818
3819static drawArraysInstanced_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3820
3821pub(crate) fn init_drawArraysInstanced_methodinfo<D: DomTypes>() {
3822 drawArraysInstanced_methodinfo.set(JSJitInfo {
3823 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3824 method: Some(drawArraysInstanced::<D>)
3825 },
3826 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3827 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3828 },
3829 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3830 _bitfield_align_1: [],
3831 _bitfield_1: __BindgenBitfieldUnit::new(
3832 new_jsjitinfo_bitfield_1!(
3833 JSJitInfo_OpType::Method as u8,
3834 JSJitInfo_AliasSet::AliasEverything as u8,
3835 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3836 false,
3837 false,
3838 false,
3839 false,
3840 false,
3841 false,
3842 0,
3843 ).to_ne_bytes()
3844 ),
3845});
3846}
3847unsafe extern "C" fn drawElementsInstanced<D: DomTypes>
3848(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3849 let mut result = false;
3850 wrap_panic(&mut || result = (|| {
3851 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3852 let this = &*(this as *const D::WebGL2RenderingContext);
3853 let args = &*args;
3854 let argc = args.argc_;
3855
3856 if argc < 5 {
3857 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.drawElementsInstanced\".");
3858 return false;
3859 }
3860 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3861 Ok(ConversionResult::Success(value)) => value,
3862 Ok(ConversionResult::Failure(error)) => {
3863 throw_type_error(cx.raw_cx(), &error);
3864 return false;
3865
3866 }
3867 _ => {
3868 return false;
3869
3870 },
3871 }
3872 ;
3873 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3874 Ok(ConversionResult::Success(value)) => value,
3875 Ok(ConversionResult::Failure(error)) => {
3876 throw_type_error(cx.raw_cx(), &error);
3877 return false;
3878
3879 }
3880 _ => {
3881 return false;
3882
3883 },
3884 }
3885 ;
3886 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
3887 Ok(ConversionResult::Success(value)) => value,
3888 Ok(ConversionResult::Failure(error)) => {
3889 throw_type_error(cx.raw_cx(), &error);
3890 return false;
3891
3892 }
3893 _ => {
3894 return false;
3895
3896 },
3897 }
3898 ;
3899 let arg3: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
3900 Ok(ConversionResult::Success(value)) => value,
3901 Ok(ConversionResult::Failure(error)) => {
3902 throw_type_error(cx.raw_cx(), &error);
3903 return false;
3904
3905 }
3906 _ => {
3907 return false;
3908
3909 },
3910 }
3911 ;
3912 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
3913 Ok(ConversionResult::Success(value)) => value,
3914 Ok(ConversionResult::Failure(error)) => {
3915 throw_type_error(cx.raw_cx(), &error);
3916 return false;
3917
3918 }
3919 _ => {
3920 return false;
3921
3922 },
3923 }
3924 ;
3925 let result: () = this.DrawElementsInstanced(arg0, arg1, arg2, arg3, arg4);
3926
3927 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3928 return true;
3929 })());
3930 result
3931}
3932
3933
3934static drawElementsInstanced_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3935
3936pub(crate) fn init_drawElementsInstanced_methodinfo<D: DomTypes>() {
3937 drawElementsInstanced_methodinfo.set(JSJitInfo {
3938 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3939 method: Some(drawElementsInstanced::<D>)
3940 },
3941 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3942 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
3943 },
3944 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3945 _bitfield_align_1: [],
3946 _bitfield_1: __BindgenBitfieldUnit::new(
3947 new_jsjitinfo_bitfield_1!(
3948 JSJitInfo_OpType::Method as u8,
3949 JSJitInfo_AliasSet::AliasEverything as u8,
3950 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3951 false,
3952 false,
3953 false,
3954 false,
3955 false,
3956 false,
3957 0,
3958 ).to_ne_bytes()
3959 ),
3960});
3961}
3962unsafe extern "C" fn drawRangeElements<D: DomTypes>
3963(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3964 let mut result = false;
3965 wrap_panic(&mut || result = (|| {
3966 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3967 let this = &*(this as *const D::WebGL2RenderingContext);
3968 let args = &*args;
3969 let argc = args.argc_;
3970
3971 if argc < 6 {
3972 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.drawRangeElements\".");
3973 return false;
3974 }
3975 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3976 Ok(ConversionResult::Success(value)) => value,
3977 Ok(ConversionResult::Failure(error)) => {
3978 throw_type_error(cx.raw_cx(), &error);
3979 return false;
3980
3981 }
3982 _ => {
3983 return false;
3984
3985 },
3986 }
3987 ;
3988 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3989 Ok(ConversionResult::Success(value)) => value,
3990 Ok(ConversionResult::Failure(error)) => {
3991 throw_type_error(cx.raw_cx(), &error);
3992 return false;
3993
3994 }
3995 _ => {
3996 return false;
3997
3998 },
3999 }
4000 ;
4001 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
4002 Ok(ConversionResult::Success(value)) => value,
4003 Ok(ConversionResult::Failure(error)) => {
4004 throw_type_error(cx.raw_cx(), &error);
4005 return false;
4006
4007 }
4008 _ => {
4009 return false;
4010
4011 },
4012 }
4013 ;
4014 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
4015 Ok(ConversionResult::Success(value)) => value,
4016 Ok(ConversionResult::Failure(error)) => {
4017 throw_type_error(cx.raw_cx(), &error);
4018 return false;
4019
4020 }
4021 _ => {
4022 return false;
4023
4024 },
4025 }
4026 ;
4027 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
4028 Ok(ConversionResult::Success(value)) => value,
4029 Ok(ConversionResult::Failure(error)) => {
4030 throw_type_error(cx.raw_cx(), &error);
4031 return false;
4032
4033 }
4034 _ => {
4035 return false;
4036
4037 },
4038 }
4039 ;
4040 let arg5: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
4041 Ok(ConversionResult::Success(value)) => value,
4042 Ok(ConversionResult::Failure(error)) => {
4043 throw_type_error(cx.raw_cx(), &error);
4044 return false;
4045
4046 }
4047 _ => {
4048 return false;
4049
4050 },
4051 }
4052 ;
4053 let result: () = this.DrawRangeElements(arg0, arg1, arg2, arg3, arg4, arg5);
4054
4055 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4056 return true;
4057 })());
4058 result
4059}
4060
4061
4062static drawRangeElements_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4063
4064pub(crate) fn init_drawRangeElements_methodinfo<D: DomTypes>() {
4065 drawRangeElements_methodinfo.set(JSJitInfo {
4066 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4067 method: Some(drawRangeElements::<D>)
4068 },
4069 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4070 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4071 },
4072 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4073 _bitfield_align_1: [],
4074 _bitfield_1: __BindgenBitfieldUnit::new(
4075 new_jsjitinfo_bitfield_1!(
4076 JSJitInfo_OpType::Method as u8,
4077 JSJitInfo_AliasSet::AliasEverything as u8,
4078 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4079 false,
4080 false,
4081 false,
4082 false,
4083 false,
4084 false,
4085 0,
4086 ).to_ne_bytes()
4087 ),
4088});
4089}
4090unsafe extern "C" fn drawBuffers<D: DomTypes>
4091(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4092 let mut result = false;
4093 wrap_panic(&mut || result = (|| {
4094 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4095 let this = &*(this as *const D::WebGL2RenderingContext);
4096 let args = &*args;
4097 let argc = args.argc_;
4098
4099 if argc < 1 {
4100 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.drawBuffers\".");
4101 return false;
4102 }
4103 let arg0: Vec<u32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4104 Ok(ConversionResult::Success(value)) => value,
4105 Ok(ConversionResult::Failure(error)) => {
4106 throw_type_error(cx.raw_cx(), &error);
4107 return false;
4108
4109 }
4110 _ => {
4111 return false;
4112
4113 },
4114 }
4115 ;
4116 let result: () = this.DrawBuffers(arg0);
4117
4118 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4119 return true;
4120 })());
4121 result
4122}
4123
4124
4125static drawBuffers_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4126
4127pub(crate) fn init_drawBuffers_methodinfo<D: DomTypes>() {
4128 drawBuffers_methodinfo.set(JSJitInfo {
4129 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4130 method: Some(drawBuffers::<D>)
4131 },
4132 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4133 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4134 },
4135 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4136 _bitfield_align_1: [],
4137 _bitfield_1: __BindgenBitfieldUnit::new(
4138 new_jsjitinfo_bitfield_1!(
4139 JSJitInfo_OpType::Method as u8,
4140 JSJitInfo_AliasSet::AliasEverything as u8,
4141 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4142 false,
4143 false,
4144 false,
4145 false,
4146 false,
4147 false,
4148 0,
4149 ).to_ne_bytes()
4150 ),
4151});
4152}
4153unsafe extern "C" fn clearBufferfv<D: DomTypes>
4154(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4155 let mut result = false;
4156 wrap_panic(&mut || result = (|| {
4157 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4158 let this = &*(this as *const D::WebGL2RenderingContext);
4159 let args = &*args;
4160 let argc = args.argc_;
4161
4162 if argc < 3 {
4163 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clearBufferfv\".");
4164 return false;
4165 }
4166 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4167 Ok(ConversionResult::Success(value)) => value,
4168 Ok(ConversionResult::Failure(error)) => {
4169 throw_type_error(cx.raw_cx(), &error);
4170 return false;
4171
4172 }
4173 _ => {
4174 return false;
4175
4176 },
4177 }
4178 ;
4179 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4180 Ok(ConversionResult::Success(value)) => value,
4181 Ok(ConversionResult::Failure(error)) => {
4182 throw_type_error(cx.raw_cx(), &error);
4183 return false;
4184
4185 }
4186 _ => {
4187 return false;
4188
4189 },
4190 }
4191 ;
4192 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
4193 Ok(ConversionResult::Success(value)) => value,
4194 Ok(ConversionResult::Failure(error)) => {
4195 throw_type_error(cx.raw_cx(), &error);
4196 return false;
4197
4198 }
4199 _ => {
4200 return false;
4201
4202 },
4203 }
4204 ;
4205 let arg3: u32 = if args.get(3).is_undefined() {
4206 0
4207 } else {
4208 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
4209 Ok(ConversionResult::Success(value)) => value,
4210 Ok(ConversionResult::Failure(error)) => {
4211 throw_type_error(cx.raw_cx(), &error);
4212 return false;
4213
4214 }
4215 _ => {
4216 return false;
4217
4218 },
4219 }
4220
4221 };
4222 let result: () = this.ClearBufferfv(arg0, arg1, arg2, arg3);
4223
4224 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4225 return true;
4226 })());
4227 result
4228}
4229
4230
4231static clearBufferfv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4232
4233pub(crate) fn init_clearBufferfv_methodinfo<D: DomTypes>() {
4234 clearBufferfv_methodinfo.set(JSJitInfo {
4235 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4236 method: Some(clearBufferfv::<D>)
4237 },
4238 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4239 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4240 },
4241 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4242 _bitfield_align_1: [],
4243 _bitfield_1: __BindgenBitfieldUnit::new(
4244 new_jsjitinfo_bitfield_1!(
4245 JSJitInfo_OpType::Method as u8,
4246 JSJitInfo_AliasSet::AliasEverything as u8,
4247 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4248 false,
4249 false,
4250 false,
4251 false,
4252 false,
4253 false,
4254 0,
4255 ).to_ne_bytes()
4256 ),
4257});
4258}
4259unsafe extern "C" fn clearBufferiv<D: DomTypes>
4260(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4261 let mut result = false;
4262 wrap_panic(&mut || result = (|| {
4263 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4264 let this = &*(this as *const D::WebGL2RenderingContext);
4265 let args = &*args;
4266 let argc = args.argc_;
4267
4268 if argc < 3 {
4269 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clearBufferiv\".");
4270 return false;
4271 }
4272 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4273 Ok(ConversionResult::Success(value)) => value,
4274 Ok(ConversionResult::Failure(error)) => {
4275 throw_type_error(cx.raw_cx(), &error);
4276 return false;
4277
4278 }
4279 _ => {
4280 return false;
4281
4282 },
4283 }
4284 ;
4285 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4286 Ok(ConversionResult::Success(value)) => value,
4287 Ok(ConversionResult::Failure(error)) => {
4288 throw_type_error(cx.raw_cx(), &error);
4289 return false;
4290
4291 }
4292 _ => {
4293 return false;
4294
4295 },
4296 }
4297 ;
4298 let arg2: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
4299 Ok(ConversionResult::Success(value)) => value,
4300 Ok(ConversionResult::Failure(error)) => {
4301 throw_type_error(cx.raw_cx(), &error);
4302 return false;
4303
4304 }
4305 _ => {
4306 return false;
4307
4308 },
4309 }
4310 ;
4311 let arg3: u32 = if args.get(3).is_undefined() {
4312 0
4313 } else {
4314 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
4315 Ok(ConversionResult::Success(value)) => value,
4316 Ok(ConversionResult::Failure(error)) => {
4317 throw_type_error(cx.raw_cx(), &error);
4318 return false;
4319
4320 }
4321 _ => {
4322 return false;
4323
4324 },
4325 }
4326
4327 };
4328 let result: () = this.ClearBufferiv(arg0, arg1, arg2, arg3);
4329
4330 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4331 return true;
4332 })());
4333 result
4334}
4335
4336
4337static clearBufferiv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4338
4339pub(crate) fn init_clearBufferiv_methodinfo<D: DomTypes>() {
4340 clearBufferiv_methodinfo.set(JSJitInfo {
4341 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4342 method: Some(clearBufferiv::<D>)
4343 },
4344 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4345 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4346 },
4347 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4348 _bitfield_align_1: [],
4349 _bitfield_1: __BindgenBitfieldUnit::new(
4350 new_jsjitinfo_bitfield_1!(
4351 JSJitInfo_OpType::Method as u8,
4352 JSJitInfo_AliasSet::AliasEverything as u8,
4353 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4354 false,
4355 false,
4356 false,
4357 false,
4358 false,
4359 false,
4360 0,
4361 ).to_ne_bytes()
4362 ),
4363});
4364}
4365unsafe extern "C" fn clearBufferuiv<D: DomTypes>
4366(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4367 let mut result = false;
4368 wrap_panic(&mut || result = (|| {
4369 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4370 let this = &*(this as *const D::WebGL2RenderingContext);
4371 let args = &*args;
4372 let argc = args.argc_;
4373
4374 if argc < 3 {
4375 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clearBufferuiv\".");
4376 return false;
4377 }
4378 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4379 Ok(ConversionResult::Success(value)) => value,
4380 Ok(ConversionResult::Failure(error)) => {
4381 throw_type_error(cx.raw_cx(), &error);
4382 return false;
4383
4384 }
4385 _ => {
4386 return false;
4387
4388 },
4389 }
4390 ;
4391 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4392 Ok(ConversionResult::Success(value)) => value,
4393 Ok(ConversionResult::Failure(error)) => {
4394 throw_type_error(cx.raw_cx(), &error);
4395 return false;
4396
4397 }
4398 _ => {
4399 return false;
4400
4401 },
4402 }
4403 ;
4404 let arg2: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
4405 Ok(ConversionResult::Success(value)) => value,
4406 Ok(ConversionResult::Failure(error)) => {
4407 throw_type_error(cx.raw_cx(), &error);
4408 return false;
4409
4410 }
4411 _ => {
4412 return false;
4413
4414 },
4415 }
4416 ;
4417 let arg3: u32 = if args.get(3).is_undefined() {
4418 0
4419 } else {
4420 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
4421 Ok(ConversionResult::Success(value)) => value,
4422 Ok(ConversionResult::Failure(error)) => {
4423 throw_type_error(cx.raw_cx(), &error);
4424 return false;
4425
4426 }
4427 _ => {
4428 return false;
4429
4430 },
4431 }
4432
4433 };
4434 let result: () = this.ClearBufferuiv(arg0, arg1, arg2, arg3);
4435
4436 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4437 return true;
4438 })());
4439 result
4440}
4441
4442
4443static clearBufferuiv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4444
4445pub(crate) fn init_clearBufferuiv_methodinfo<D: DomTypes>() {
4446 clearBufferuiv_methodinfo.set(JSJitInfo {
4447 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4448 method: Some(clearBufferuiv::<D>)
4449 },
4450 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4451 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4452 },
4453 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4454 _bitfield_align_1: [],
4455 _bitfield_1: __BindgenBitfieldUnit::new(
4456 new_jsjitinfo_bitfield_1!(
4457 JSJitInfo_OpType::Method as u8,
4458 JSJitInfo_AliasSet::AliasEverything as u8,
4459 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4460 false,
4461 false,
4462 false,
4463 false,
4464 false,
4465 false,
4466 0,
4467 ).to_ne_bytes()
4468 ),
4469});
4470}
4471unsafe extern "C" fn clearBufferfi<D: DomTypes>
4472(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4473 let mut result = false;
4474 wrap_panic(&mut || result = (|| {
4475 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4476 let this = &*(this as *const D::WebGL2RenderingContext);
4477 let args = &*args;
4478 let argc = args.argc_;
4479
4480 if argc < 4 {
4481 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clearBufferfi\".");
4482 return false;
4483 }
4484 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4485 Ok(ConversionResult::Success(value)) => value,
4486 Ok(ConversionResult::Failure(error)) => {
4487 throw_type_error(cx.raw_cx(), &error);
4488 return false;
4489
4490 }
4491 _ => {
4492 return false;
4493
4494 },
4495 }
4496 ;
4497 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4498 Ok(ConversionResult::Success(value)) => value,
4499 Ok(ConversionResult::Failure(error)) => {
4500 throw_type_error(cx.raw_cx(), &error);
4501 return false;
4502
4503 }
4504 _ => {
4505 return false;
4506
4507 },
4508 }
4509 ;
4510 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
4511 Ok(ConversionResult::Success(value)) => value,
4512 Ok(ConversionResult::Failure(error)) => {
4513 throw_type_error(cx.raw_cx(), &error);
4514 return false;
4515
4516 }
4517 _ => {
4518 return false;
4519
4520 },
4521 }
4522 ;
4523 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
4524 Ok(ConversionResult::Success(value)) => value,
4525 Ok(ConversionResult::Failure(error)) => {
4526 throw_type_error(cx.raw_cx(), &error);
4527 return false;
4528
4529 }
4530 _ => {
4531 return false;
4532
4533 },
4534 }
4535 ;
4536 let result: () = this.ClearBufferfi(arg0, arg1, arg2, arg3);
4537
4538 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4539 return true;
4540 })());
4541 result
4542}
4543
4544
4545static clearBufferfi_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4546
4547pub(crate) fn init_clearBufferfi_methodinfo<D: DomTypes>() {
4548 clearBufferfi_methodinfo.set(JSJitInfo {
4549 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4550 method: Some(clearBufferfi::<D>)
4551 },
4552 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4553 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4554 },
4555 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4556 _bitfield_align_1: [],
4557 _bitfield_1: __BindgenBitfieldUnit::new(
4558 new_jsjitinfo_bitfield_1!(
4559 JSJitInfo_OpType::Method as u8,
4560 JSJitInfo_AliasSet::AliasEverything as u8,
4561 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4562 false,
4563 false,
4564 false,
4565 false,
4566 false,
4567 false,
4568 0,
4569 ).to_ne_bytes()
4570 ),
4571});
4572}
4573unsafe extern "C" fn createQuery<D: DomTypes>
4574(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4575 let mut result = false;
4576 wrap_panic(&mut || result = (|| {
4577 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4578 let this = &*(this as *const D::WebGL2RenderingContext);
4579 let args = &*args;
4580 let argc = args.argc_;
4581 let result: Option<DomRoot<D::WebGLQuery>> = this.CreateQuery();
4582
4583 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4584 return true;
4585 })());
4586 result
4587}
4588
4589
4590static createQuery_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4591
4592pub(crate) fn init_createQuery_methodinfo<D: DomTypes>() {
4593 createQuery_methodinfo.set(JSJitInfo {
4594 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4595 method: Some(createQuery::<D>)
4596 },
4597 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4598 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4599 },
4600 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4601 _bitfield_align_1: [],
4602 _bitfield_1: __BindgenBitfieldUnit::new(
4603 new_jsjitinfo_bitfield_1!(
4604 JSJitInfo_OpType::Method as u8,
4605 JSJitInfo_AliasSet::AliasEverything as u8,
4606 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4607 true,
4608 false,
4609 false,
4610 false,
4611 false,
4612 false,
4613 0,
4614 ).to_ne_bytes()
4615 ),
4616});
4617}
4618unsafe extern "C" fn deleteQuery<D: DomTypes>
4619(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4620 let mut result = false;
4621 wrap_panic(&mut || result = (|| {
4622 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4623 let this = &*(this as *const D::WebGL2RenderingContext);
4624 let args = &*args;
4625 let argc = args.argc_;
4626
4627 if argc < 1 {
4628 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteQuery\".");
4629 return false;
4630 }
4631 let arg0: Option<DomRoot<D::WebGLQuery>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4632 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4633 Ok(val) => val,
4634 Err(()) => {
4635 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLQuery.");
4636 return false;
4637
4638 }
4639 }
4640 )
4641 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
4642 None
4643 } else {
4644 throw_type_error(cx.raw_cx(), "Value is not an object.");
4645 return false;
4646
4647 };
4648 let result: () = this.DeleteQuery(arg0.as_deref());
4649
4650 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4651 return true;
4652 })());
4653 result
4654}
4655
4656
4657static deleteQuery_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4658
4659pub(crate) fn init_deleteQuery_methodinfo<D: DomTypes>() {
4660 deleteQuery_methodinfo.set(JSJitInfo {
4661 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4662 method: Some(deleteQuery::<D>)
4663 },
4664 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4665 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4666 },
4667 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4668 _bitfield_align_1: [],
4669 _bitfield_1: __BindgenBitfieldUnit::new(
4670 new_jsjitinfo_bitfield_1!(
4671 JSJitInfo_OpType::Method as u8,
4672 JSJitInfo_AliasSet::AliasEverything as u8,
4673 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4674 false,
4675 false,
4676 false,
4677 false,
4678 false,
4679 false,
4680 0,
4681 ).to_ne_bytes()
4682 ),
4683});
4684}
4685unsafe extern "C" fn isQuery<D: DomTypes>
4686(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4687 let mut result = false;
4688 wrap_panic(&mut || result = (|| {
4689 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4690 let this = &*(this as *const D::WebGL2RenderingContext);
4691 let args = &*args;
4692 let argc = args.argc_;
4693
4694 if argc < 1 {
4695 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isQuery\".");
4696 return false;
4697 }
4698 let arg0: Option<DomRoot<D::WebGLQuery>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4699 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4700 Ok(val) => val,
4701 Err(()) => {
4702 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLQuery.");
4703 return false;
4704
4705 }
4706 }
4707 )
4708 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
4709 None
4710 } else {
4711 throw_type_error(cx.raw_cx(), "Value is not an object.");
4712 return false;
4713
4714 };
4715 let result: bool = this.IsQuery(arg0.as_deref());
4716
4717 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4718 return true;
4719 })());
4720 result
4721}
4722
4723
4724static isQuery_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4725
4726pub(crate) fn init_isQuery_methodinfo<D: DomTypes>() {
4727 isQuery_methodinfo.set(JSJitInfo {
4728 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4729 method: Some(isQuery::<D>)
4730 },
4731 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4732 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4733 },
4734 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4735 _bitfield_align_1: [],
4736 _bitfield_1: __BindgenBitfieldUnit::new(
4737 new_jsjitinfo_bitfield_1!(
4738 JSJitInfo_OpType::Method as u8,
4739 JSJitInfo_AliasSet::AliasEverything as u8,
4740 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
4741 false,
4742 false,
4743 false,
4744 false,
4745 false,
4746 false,
4747 0,
4748 ).to_ne_bytes()
4749 ),
4750});
4751}
4752unsafe extern "C" fn beginQuery<D: DomTypes>
4753(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4754 let mut result = false;
4755 wrap_panic(&mut || result = (|| {
4756 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4757 let this = &*(this as *const D::WebGL2RenderingContext);
4758 let args = &*args;
4759 let argc = args.argc_;
4760
4761 if argc < 2 {
4762 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.beginQuery\".");
4763 return false;
4764 }
4765 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4766 Ok(ConversionResult::Success(value)) => value,
4767 Ok(ConversionResult::Failure(error)) => {
4768 throw_type_error(cx.raw_cx(), &error);
4769 return false;
4770
4771 }
4772 _ => {
4773 return false;
4774
4775 },
4776 }
4777 ;
4778 let arg1: DomRoot<D::WebGLQuery> = if HandleValue::from_raw(args.get(1)).get().is_object() {
4779 match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
4780 Ok(val) => val,
4781 Err(()) => {
4782 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLQuery.");
4783 return false;
4784
4785 }
4786 }
4787
4788 } else {
4789 throw_type_error(cx.raw_cx(), "Value is not an object.");
4790 return false;
4791
4792 };
4793 let result: () = this.BeginQuery(arg0, &arg1);
4794
4795 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4796 return true;
4797 })());
4798 result
4799}
4800
4801
4802static beginQuery_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4803
4804pub(crate) fn init_beginQuery_methodinfo<D: DomTypes>() {
4805 beginQuery_methodinfo.set(JSJitInfo {
4806 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4807 method: Some(beginQuery::<D>)
4808 },
4809 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4810 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4811 },
4812 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4813 _bitfield_align_1: [],
4814 _bitfield_1: __BindgenBitfieldUnit::new(
4815 new_jsjitinfo_bitfield_1!(
4816 JSJitInfo_OpType::Method as u8,
4817 JSJitInfo_AliasSet::AliasEverything as u8,
4818 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4819 false,
4820 false,
4821 false,
4822 false,
4823 false,
4824 false,
4825 0,
4826 ).to_ne_bytes()
4827 ),
4828});
4829}
4830unsafe extern "C" fn endQuery<D: DomTypes>
4831(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4832 let mut result = false;
4833 wrap_panic(&mut || result = (|| {
4834 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4835 let this = &*(this as *const D::WebGL2RenderingContext);
4836 let args = &*args;
4837 let argc = args.argc_;
4838
4839 if argc < 1 {
4840 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.endQuery\".");
4841 return false;
4842 }
4843 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4844 Ok(ConversionResult::Success(value)) => value,
4845 Ok(ConversionResult::Failure(error)) => {
4846 throw_type_error(cx.raw_cx(), &error);
4847 return false;
4848
4849 }
4850 _ => {
4851 return false;
4852
4853 },
4854 }
4855 ;
4856 let result: () = this.EndQuery(arg0);
4857
4858 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4859 return true;
4860 })());
4861 result
4862}
4863
4864
4865static endQuery_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4866
4867pub(crate) fn init_endQuery_methodinfo<D: DomTypes>() {
4868 endQuery_methodinfo.set(JSJitInfo {
4869 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4870 method: Some(endQuery::<D>)
4871 },
4872 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4873 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4874 },
4875 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4876 _bitfield_align_1: [],
4877 _bitfield_1: __BindgenBitfieldUnit::new(
4878 new_jsjitinfo_bitfield_1!(
4879 JSJitInfo_OpType::Method as u8,
4880 JSJitInfo_AliasSet::AliasEverything as u8,
4881 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4882 false,
4883 false,
4884 false,
4885 false,
4886 false,
4887 false,
4888 0,
4889 ).to_ne_bytes()
4890 ),
4891});
4892}
4893unsafe extern "C" fn getQuery<D: DomTypes>
4894(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4895 let mut result = false;
4896 wrap_panic(&mut || result = (|| {
4897 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4898 let this = &*(this as *const D::WebGL2RenderingContext);
4899 let args = &*args;
4900 let argc = args.argc_;
4901
4902 if argc < 2 {
4903 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getQuery\".");
4904 return false;
4905 }
4906 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4907 Ok(ConversionResult::Success(value)) => value,
4908 Ok(ConversionResult::Failure(error)) => {
4909 throw_type_error(cx.raw_cx(), &error);
4910 return false;
4911
4912 }
4913 _ => {
4914 return false;
4915
4916 },
4917 }
4918 ;
4919 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4920 Ok(ConversionResult::Success(value)) => value,
4921 Ok(ConversionResult::Failure(error)) => {
4922 throw_type_error(cx.raw_cx(), &error);
4923 return false;
4924
4925 }
4926 _ => {
4927 return false;
4928
4929 },
4930 }
4931 ;
4932 let result: Option<DomRoot<D::WebGLQuery>> = this.GetQuery(arg0, arg1);
4933
4934 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4935 return true;
4936 })());
4937 result
4938}
4939
4940
4941static getQuery_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4942
4943pub(crate) fn init_getQuery_methodinfo<D: DomTypes>() {
4944 getQuery_methodinfo.set(JSJitInfo {
4945 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4946 method: Some(getQuery::<D>)
4947 },
4948 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4949 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
4950 },
4951 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4952 _bitfield_align_1: [],
4953 _bitfield_1: __BindgenBitfieldUnit::new(
4954 new_jsjitinfo_bitfield_1!(
4955 JSJitInfo_OpType::Method as u8,
4956 JSJitInfo_AliasSet::AliasEverything as u8,
4957 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4958 false,
4959 false,
4960 false,
4961 false,
4962 false,
4963 false,
4964 0,
4965 ).to_ne_bytes()
4966 ),
4967});
4968}
4969unsafe extern "C" fn getQueryParameter<D: DomTypes>
4970(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4971 let mut result = false;
4972 wrap_panic(&mut || result = (|| {
4973 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4974 let this = &*(this as *const D::WebGL2RenderingContext);
4975 let args = &*args;
4976 let argc = args.argc_;
4977
4978 if argc < 2 {
4979 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getQueryParameter\".");
4980 return false;
4981 }
4982 let arg0: DomRoot<D::WebGLQuery> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4983 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4984 Ok(val) => val,
4985 Err(()) => {
4986 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLQuery.");
4987 return false;
4988
4989 }
4990 }
4991
4992 } else {
4993 throw_type_error(cx.raw_cx(), "Value is not an object.");
4994 return false;
4995
4996 };
4997 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4998 Ok(ConversionResult::Success(value)) => value,
4999 Ok(ConversionResult::Failure(error)) => {
5000 throw_type_error(cx.raw_cx(), &error);
5001 return false;
5002
5003 }
5004 _ => {
5005 return false;
5006
5007 },
5008 }
5009 ;
5010 rooted!(&in(cx) let mut retval: JSVal);
5011 let result: () = this.GetQueryParameter(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, retval.handle_mut());
5012
5013 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5014 return true;
5015 })());
5016 result
5017}
5018
5019
5020static getQueryParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5021
5022pub(crate) fn init_getQueryParameter_methodinfo<D: DomTypes>() {
5023 getQueryParameter_methodinfo.set(JSJitInfo {
5024 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5025 method: Some(getQueryParameter::<D>)
5026 },
5027 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5028 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5029 },
5030 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5031 _bitfield_align_1: [],
5032 _bitfield_1: __BindgenBitfieldUnit::new(
5033 new_jsjitinfo_bitfield_1!(
5034 JSJitInfo_OpType::Method as u8,
5035 JSJitInfo_AliasSet::AliasEverything as u8,
5036 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5037 false,
5038 false,
5039 false,
5040 false,
5041 false,
5042 false,
5043 0,
5044 ).to_ne_bytes()
5045 ),
5046});
5047}
5048unsafe extern "C" fn createSampler<D: DomTypes>
5049(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5050 let mut result = false;
5051 wrap_panic(&mut || result = (|| {
5052 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5053 let this = &*(this as *const D::WebGL2RenderingContext);
5054 let args = &*args;
5055 let argc = args.argc_;
5056 let result: Option<DomRoot<D::WebGLSampler>> = this.CreateSampler();
5057
5058 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5059 return true;
5060 })());
5061 result
5062}
5063
5064
5065static createSampler_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5066
5067pub(crate) fn init_createSampler_methodinfo<D: DomTypes>() {
5068 createSampler_methodinfo.set(JSJitInfo {
5069 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5070 method: Some(createSampler::<D>)
5071 },
5072 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5073 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5074 },
5075 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5076 _bitfield_align_1: [],
5077 _bitfield_1: __BindgenBitfieldUnit::new(
5078 new_jsjitinfo_bitfield_1!(
5079 JSJitInfo_OpType::Method as u8,
5080 JSJitInfo_AliasSet::AliasEverything as u8,
5081 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5082 true,
5083 false,
5084 false,
5085 false,
5086 false,
5087 false,
5088 0,
5089 ).to_ne_bytes()
5090 ),
5091});
5092}
5093unsafe extern "C" fn deleteSampler<D: DomTypes>
5094(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5095 let mut result = false;
5096 wrap_panic(&mut || result = (|| {
5097 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5098 let this = &*(this as *const D::WebGL2RenderingContext);
5099 let args = &*args;
5100 let argc = args.argc_;
5101
5102 if argc < 1 {
5103 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteSampler\".");
5104 return false;
5105 }
5106 let arg0: Option<DomRoot<D::WebGLSampler>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5107 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5108 Ok(val) => val,
5109 Err(()) => {
5110 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSampler.");
5111 return false;
5112
5113 }
5114 }
5115 )
5116 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
5117 None
5118 } else {
5119 throw_type_error(cx.raw_cx(), "Value is not an object.");
5120 return false;
5121
5122 };
5123 let result: () = this.DeleteSampler(arg0.as_deref());
5124
5125 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5126 return true;
5127 })());
5128 result
5129}
5130
5131
5132static deleteSampler_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5133
5134pub(crate) fn init_deleteSampler_methodinfo<D: DomTypes>() {
5135 deleteSampler_methodinfo.set(JSJitInfo {
5136 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5137 method: Some(deleteSampler::<D>)
5138 },
5139 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5140 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5141 },
5142 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5143 _bitfield_align_1: [],
5144 _bitfield_1: __BindgenBitfieldUnit::new(
5145 new_jsjitinfo_bitfield_1!(
5146 JSJitInfo_OpType::Method as u8,
5147 JSJitInfo_AliasSet::AliasEverything as u8,
5148 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5149 false,
5150 false,
5151 false,
5152 false,
5153 false,
5154 false,
5155 0,
5156 ).to_ne_bytes()
5157 ),
5158});
5159}
5160unsafe extern "C" fn isSampler<D: DomTypes>
5161(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5162 let mut result = false;
5163 wrap_panic(&mut || result = (|| {
5164 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5165 let this = &*(this as *const D::WebGL2RenderingContext);
5166 let args = &*args;
5167 let argc = args.argc_;
5168
5169 if argc < 1 {
5170 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isSampler\".");
5171 return false;
5172 }
5173 let arg0: Option<DomRoot<D::WebGLSampler>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5174 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5175 Ok(val) => val,
5176 Err(()) => {
5177 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSampler.");
5178 return false;
5179
5180 }
5181 }
5182 )
5183 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
5184 None
5185 } else {
5186 throw_type_error(cx.raw_cx(), "Value is not an object.");
5187 return false;
5188
5189 };
5190 let result: bool = this.IsSampler(arg0.as_deref());
5191
5192 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5193 return true;
5194 })());
5195 result
5196}
5197
5198
5199static isSampler_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5200
5201pub(crate) fn init_isSampler_methodinfo<D: DomTypes>() {
5202 isSampler_methodinfo.set(JSJitInfo {
5203 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5204 method: Some(isSampler::<D>)
5205 },
5206 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5207 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5208 },
5209 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5210 _bitfield_align_1: [],
5211 _bitfield_1: __BindgenBitfieldUnit::new(
5212 new_jsjitinfo_bitfield_1!(
5213 JSJitInfo_OpType::Method as u8,
5214 JSJitInfo_AliasSet::AliasEverything as u8,
5215 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
5216 false,
5217 false,
5218 false,
5219 false,
5220 false,
5221 false,
5222 0,
5223 ).to_ne_bytes()
5224 ),
5225});
5226}
5227unsafe extern "C" fn bindSampler<D: DomTypes>
5228(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5229 let mut result = false;
5230 wrap_panic(&mut || result = (|| {
5231 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5232 let this = &*(this as *const D::WebGL2RenderingContext);
5233 let args = &*args;
5234 let argc = args.argc_;
5235
5236 if argc < 2 {
5237 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindSampler\".");
5238 return false;
5239 }
5240 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5241 Ok(ConversionResult::Success(value)) => value,
5242 Ok(ConversionResult::Failure(error)) => {
5243 throw_type_error(cx.raw_cx(), &error);
5244 return false;
5245
5246 }
5247 _ => {
5248 return false;
5249
5250 },
5251 }
5252 ;
5253 let arg1: Option<DomRoot<D::WebGLSampler>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
5254 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
5255 Ok(val) => val,
5256 Err(()) => {
5257 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSampler.");
5258 return false;
5259
5260 }
5261 }
5262 )
5263 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
5264 None
5265 } else {
5266 throw_type_error(cx.raw_cx(), "Value is not an object.");
5267 return false;
5268
5269 };
5270 let result: () = this.BindSampler(arg0, arg1.as_deref());
5271
5272 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5273 return true;
5274 })());
5275 result
5276}
5277
5278
5279static bindSampler_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5280
5281pub(crate) fn init_bindSampler_methodinfo<D: DomTypes>() {
5282 bindSampler_methodinfo.set(JSJitInfo {
5283 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5284 method: Some(bindSampler::<D>)
5285 },
5286 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5287 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5288 },
5289 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5290 _bitfield_align_1: [],
5291 _bitfield_1: __BindgenBitfieldUnit::new(
5292 new_jsjitinfo_bitfield_1!(
5293 JSJitInfo_OpType::Method as u8,
5294 JSJitInfo_AliasSet::AliasEverything as u8,
5295 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5296 false,
5297 false,
5298 false,
5299 false,
5300 false,
5301 false,
5302 0,
5303 ).to_ne_bytes()
5304 ),
5305});
5306}
5307unsafe extern "C" fn samplerParameteri<D: DomTypes>
5308(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5309 let mut result = false;
5310 wrap_panic(&mut || result = (|| {
5311 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5312 let this = &*(this as *const D::WebGL2RenderingContext);
5313 let args = &*args;
5314 let argc = args.argc_;
5315
5316 if argc < 3 {
5317 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.samplerParameteri\".");
5318 return false;
5319 }
5320 let arg0: DomRoot<D::WebGLSampler> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5321 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5322 Ok(val) => val,
5323 Err(()) => {
5324 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSampler.");
5325 return false;
5326
5327 }
5328 }
5329
5330 } else {
5331 throw_type_error(cx.raw_cx(), "Value is not an object.");
5332 return false;
5333
5334 };
5335 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5336 Ok(ConversionResult::Success(value)) => value,
5337 Ok(ConversionResult::Failure(error)) => {
5338 throw_type_error(cx.raw_cx(), &error);
5339 return false;
5340
5341 }
5342 _ => {
5343 return false;
5344
5345 },
5346 }
5347 ;
5348 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
5349 Ok(ConversionResult::Success(value)) => value,
5350 Ok(ConversionResult::Failure(error)) => {
5351 throw_type_error(cx.raw_cx(), &error);
5352 return false;
5353
5354 }
5355 _ => {
5356 return false;
5357
5358 },
5359 }
5360 ;
5361 let result: () = this.SamplerParameteri(&arg0, arg1, arg2);
5362
5363 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5364 return true;
5365 })());
5366 result
5367}
5368
5369
5370static samplerParameteri_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5371
5372pub(crate) fn init_samplerParameteri_methodinfo<D: DomTypes>() {
5373 samplerParameteri_methodinfo.set(JSJitInfo {
5374 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5375 method: Some(samplerParameteri::<D>)
5376 },
5377 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5378 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5379 },
5380 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5381 _bitfield_align_1: [],
5382 _bitfield_1: __BindgenBitfieldUnit::new(
5383 new_jsjitinfo_bitfield_1!(
5384 JSJitInfo_OpType::Method as u8,
5385 JSJitInfo_AliasSet::AliasEverything as u8,
5386 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5387 false,
5388 false,
5389 false,
5390 false,
5391 false,
5392 false,
5393 0,
5394 ).to_ne_bytes()
5395 ),
5396});
5397}
5398unsafe extern "C" fn samplerParameterf<D: DomTypes>
5399(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5400 let mut result = false;
5401 wrap_panic(&mut || result = (|| {
5402 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5403 let this = &*(this as *const D::WebGL2RenderingContext);
5404 let args = &*args;
5405 let argc = args.argc_;
5406
5407 if argc < 3 {
5408 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.samplerParameterf\".");
5409 return false;
5410 }
5411 let arg0: DomRoot<D::WebGLSampler> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5412 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5413 Ok(val) => val,
5414 Err(()) => {
5415 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSampler.");
5416 return false;
5417
5418 }
5419 }
5420
5421 } else {
5422 throw_type_error(cx.raw_cx(), "Value is not an object.");
5423 return false;
5424
5425 };
5426 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5427 Ok(ConversionResult::Success(value)) => value,
5428 Ok(ConversionResult::Failure(error)) => {
5429 throw_type_error(cx.raw_cx(), &error);
5430 return false;
5431
5432 }
5433 _ => {
5434 return false;
5435
5436 },
5437 }
5438 ;
5439 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
5440 Ok(ConversionResult::Success(value)) => value,
5441 Ok(ConversionResult::Failure(error)) => {
5442 throw_type_error(cx.raw_cx(), &error);
5443 return false;
5444
5445 }
5446 _ => {
5447 return false;
5448
5449 },
5450 }
5451 ;
5452 let result: () = this.SamplerParameterf(&arg0, arg1, arg2);
5453
5454 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5455 return true;
5456 })());
5457 result
5458}
5459
5460
5461static samplerParameterf_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5462
5463pub(crate) fn init_samplerParameterf_methodinfo<D: DomTypes>() {
5464 samplerParameterf_methodinfo.set(JSJitInfo {
5465 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5466 method: Some(samplerParameterf::<D>)
5467 },
5468 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5469 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5470 },
5471 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5472 _bitfield_align_1: [],
5473 _bitfield_1: __BindgenBitfieldUnit::new(
5474 new_jsjitinfo_bitfield_1!(
5475 JSJitInfo_OpType::Method as u8,
5476 JSJitInfo_AliasSet::AliasEverything as u8,
5477 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5478 false,
5479 false,
5480 false,
5481 false,
5482 false,
5483 false,
5484 0,
5485 ).to_ne_bytes()
5486 ),
5487});
5488}
5489unsafe extern "C" fn getSamplerParameter<D: DomTypes>
5490(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5491 let mut result = false;
5492 wrap_panic(&mut || result = (|| {
5493 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5494 let this = &*(this as *const D::WebGL2RenderingContext);
5495 let args = &*args;
5496 let argc = args.argc_;
5497
5498 if argc < 2 {
5499 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getSamplerParameter\".");
5500 return false;
5501 }
5502 let arg0: DomRoot<D::WebGLSampler> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5503 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5504 Ok(val) => val,
5505 Err(()) => {
5506 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSampler.");
5507 return false;
5508
5509 }
5510 }
5511
5512 } else {
5513 throw_type_error(cx.raw_cx(), "Value is not an object.");
5514 return false;
5515
5516 };
5517 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5518 Ok(ConversionResult::Success(value)) => value,
5519 Ok(ConversionResult::Failure(error)) => {
5520 throw_type_error(cx.raw_cx(), &error);
5521 return false;
5522
5523 }
5524 _ => {
5525 return false;
5526
5527 },
5528 }
5529 ;
5530 rooted!(&in(cx) let mut retval: JSVal);
5531 let result: () = this.GetSamplerParameter(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, retval.handle_mut());
5532
5533 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5534 return true;
5535 })());
5536 result
5537}
5538
5539
5540static getSamplerParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5541
5542pub(crate) fn init_getSamplerParameter_methodinfo<D: DomTypes>() {
5543 getSamplerParameter_methodinfo.set(JSJitInfo {
5544 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5545 method: Some(getSamplerParameter::<D>)
5546 },
5547 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5548 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5549 },
5550 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5551 _bitfield_align_1: [],
5552 _bitfield_1: __BindgenBitfieldUnit::new(
5553 new_jsjitinfo_bitfield_1!(
5554 JSJitInfo_OpType::Method as u8,
5555 JSJitInfo_AliasSet::AliasEverything as u8,
5556 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5557 false,
5558 false,
5559 false,
5560 false,
5561 false,
5562 false,
5563 0,
5564 ).to_ne_bytes()
5565 ),
5566});
5567}
5568unsafe extern "C" fn fenceSync<D: DomTypes>
5569(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5570 let mut result = false;
5571 wrap_panic(&mut || result = (|| {
5572 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5573 let this = &*(this as *const D::WebGL2RenderingContext);
5574 let args = &*args;
5575 let argc = args.argc_;
5576
5577 if argc < 2 {
5578 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.fenceSync\".");
5579 return false;
5580 }
5581 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5582 Ok(ConversionResult::Success(value)) => value,
5583 Ok(ConversionResult::Failure(error)) => {
5584 throw_type_error(cx.raw_cx(), &error);
5585 return false;
5586
5587 }
5588 _ => {
5589 return false;
5590
5591 },
5592 }
5593 ;
5594 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5595 Ok(ConversionResult::Success(value)) => value,
5596 Ok(ConversionResult::Failure(error)) => {
5597 throw_type_error(cx.raw_cx(), &error);
5598 return false;
5599
5600 }
5601 _ => {
5602 return false;
5603
5604 },
5605 }
5606 ;
5607 let result: Option<DomRoot<D::WebGLSync>> = this.FenceSync(arg0, arg1);
5608
5609 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5610 return true;
5611 })());
5612 result
5613}
5614
5615
5616static fenceSync_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5617
5618pub(crate) fn init_fenceSync_methodinfo<D: DomTypes>() {
5619 fenceSync_methodinfo.set(JSJitInfo {
5620 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5621 method: Some(fenceSync::<D>)
5622 },
5623 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5624 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5625 },
5626 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5627 _bitfield_align_1: [],
5628 _bitfield_1: __BindgenBitfieldUnit::new(
5629 new_jsjitinfo_bitfield_1!(
5630 JSJitInfo_OpType::Method as u8,
5631 JSJitInfo_AliasSet::AliasEverything as u8,
5632 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5633 false,
5634 false,
5635 false,
5636 false,
5637 false,
5638 false,
5639 0,
5640 ).to_ne_bytes()
5641 ),
5642});
5643}
5644unsafe extern "C" fn isSync<D: DomTypes>
5645(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5646 let mut result = false;
5647 wrap_panic(&mut || result = (|| {
5648 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5649 let this = &*(this as *const D::WebGL2RenderingContext);
5650 let args = &*args;
5651 let argc = args.argc_;
5652
5653 if argc < 1 {
5654 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isSync\".");
5655 return false;
5656 }
5657 let arg0: Option<DomRoot<D::WebGLSync>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5658 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5659 Ok(val) => val,
5660 Err(()) => {
5661 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSync.");
5662 return false;
5663
5664 }
5665 }
5666 )
5667 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
5668 None
5669 } else {
5670 throw_type_error(cx.raw_cx(), "Value is not an object.");
5671 return false;
5672
5673 };
5674 let result: bool = this.IsSync(arg0.as_deref());
5675
5676 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5677 return true;
5678 })());
5679 result
5680}
5681
5682
5683static isSync_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5684
5685pub(crate) fn init_isSync_methodinfo<D: DomTypes>() {
5686 isSync_methodinfo.set(JSJitInfo {
5687 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5688 method: Some(isSync::<D>)
5689 },
5690 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5691 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5692 },
5693 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5694 _bitfield_align_1: [],
5695 _bitfield_1: __BindgenBitfieldUnit::new(
5696 new_jsjitinfo_bitfield_1!(
5697 JSJitInfo_OpType::Method as u8,
5698 JSJitInfo_AliasSet::AliasEverything as u8,
5699 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
5700 false,
5701 false,
5702 false,
5703 false,
5704 false,
5705 false,
5706 0,
5707 ).to_ne_bytes()
5708 ),
5709});
5710}
5711unsafe extern "C" fn deleteSync<D: DomTypes>
5712(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5713 let mut result = false;
5714 wrap_panic(&mut || result = (|| {
5715 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5716 let this = &*(this as *const D::WebGL2RenderingContext);
5717 let args = &*args;
5718 let argc = args.argc_;
5719
5720 if argc < 1 {
5721 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteSync\".");
5722 return false;
5723 }
5724 let arg0: Option<DomRoot<D::WebGLSync>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5725 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5726 Ok(val) => val,
5727 Err(()) => {
5728 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSync.");
5729 return false;
5730
5731 }
5732 }
5733 )
5734 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
5735 None
5736 } else {
5737 throw_type_error(cx.raw_cx(), "Value is not an object.");
5738 return false;
5739
5740 };
5741 let result: () = this.DeleteSync(arg0.as_deref());
5742
5743 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5744 return true;
5745 })());
5746 result
5747}
5748
5749
5750static deleteSync_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5751
5752pub(crate) fn init_deleteSync_methodinfo<D: DomTypes>() {
5753 deleteSync_methodinfo.set(JSJitInfo {
5754 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5755 method: Some(deleteSync::<D>)
5756 },
5757 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5758 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5759 },
5760 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5761 _bitfield_align_1: [],
5762 _bitfield_1: __BindgenBitfieldUnit::new(
5763 new_jsjitinfo_bitfield_1!(
5764 JSJitInfo_OpType::Method as u8,
5765 JSJitInfo_AliasSet::AliasEverything as u8,
5766 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5767 false,
5768 false,
5769 false,
5770 false,
5771 false,
5772 false,
5773 0,
5774 ).to_ne_bytes()
5775 ),
5776});
5777}
5778unsafe extern "C" fn clientWaitSync<D: DomTypes>
5779(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5780 let mut result = false;
5781 wrap_panic(&mut || result = (|| {
5782 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5783 let this = &*(this as *const D::WebGL2RenderingContext);
5784 let args = &*args;
5785 let argc = args.argc_;
5786
5787 if argc < 3 {
5788 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clientWaitSync\".");
5789 return false;
5790 }
5791 let arg0: DomRoot<D::WebGLSync> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5792 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5793 Ok(val) => val,
5794 Err(()) => {
5795 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSync.");
5796 return false;
5797
5798 }
5799 }
5800
5801 } else {
5802 throw_type_error(cx.raw_cx(), "Value is not an object.");
5803 return false;
5804
5805 };
5806 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5807 Ok(ConversionResult::Success(value)) => value,
5808 Ok(ConversionResult::Failure(error)) => {
5809 throw_type_error(cx.raw_cx(), &error);
5810 return false;
5811
5812 }
5813 _ => {
5814 return false;
5815
5816 },
5817 }
5818 ;
5819 let arg2: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
5820 Ok(ConversionResult::Success(value)) => value,
5821 Ok(ConversionResult::Failure(error)) => {
5822 throw_type_error(cx.raw_cx(), &error);
5823 return false;
5824
5825 }
5826 _ => {
5827 return false;
5828
5829 },
5830 }
5831 ;
5832 let result: u32 = this.ClientWaitSync(&arg0, arg1, arg2);
5833
5834 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5835 return true;
5836 })());
5837 result
5838}
5839
5840
5841static clientWaitSync_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5842
5843pub(crate) fn init_clientWaitSync_methodinfo<D: DomTypes>() {
5844 clientWaitSync_methodinfo.set(JSJitInfo {
5845 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5846 method: Some(clientWaitSync::<D>)
5847 },
5848 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5849 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5850 },
5851 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5852 _bitfield_align_1: [],
5853 _bitfield_1: __BindgenBitfieldUnit::new(
5854 new_jsjitinfo_bitfield_1!(
5855 JSJitInfo_OpType::Method as u8,
5856 JSJitInfo_AliasSet::AliasEverything as u8,
5857 JSValueType::JSVAL_TYPE_DOUBLE as u8,
5858 false,
5859 false,
5860 false,
5861 false,
5862 false,
5863 false,
5864 0,
5865 ).to_ne_bytes()
5866 ),
5867});
5868}
5869unsafe extern "C" fn waitSync<D: DomTypes>
5870(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5871 let mut result = false;
5872 wrap_panic(&mut || result = (|| {
5873 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5874 let this = &*(this as *const D::WebGL2RenderingContext);
5875 let args = &*args;
5876 let argc = args.argc_;
5877
5878 if argc < 3 {
5879 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.waitSync\".");
5880 return false;
5881 }
5882 let arg0: DomRoot<D::WebGLSync> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5883 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5884 Ok(val) => val,
5885 Err(()) => {
5886 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSync.");
5887 return false;
5888
5889 }
5890 }
5891
5892 } else {
5893 throw_type_error(cx.raw_cx(), "Value is not an object.");
5894 return false;
5895
5896 };
5897 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5898 Ok(ConversionResult::Success(value)) => value,
5899 Ok(ConversionResult::Failure(error)) => {
5900 throw_type_error(cx.raw_cx(), &error);
5901 return false;
5902
5903 }
5904 _ => {
5905 return false;
5906
5907 },
5908 }
5909 ;
5910 let arg2: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
5911 Ok(ConversionResult::Success(value)) => value,
5912 Ok(ConversionResult::Failure(error)) => {
5913 throw_type_error(cx.raw_cx(), &error);
5914 return false;
5915
5916 }
5917 _ => {
5918 return false;
5919
5920 },
5921 }
5922 ;
5923 let result: () = this.WaitSync(&arg0, arg1, arg2);
5924
5925 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5926 return true;
5927 })());
5928 result
5929}
5930
5931
5932static waitSync_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5933
5934pub(crate) fn init_waitSync_methodinfo<D: DomTypes>() {
5935 waitSync_methodinfo.set(JSJitInfo {
5936 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5937 method: Some(waitSync::<D>)
5938 },
5939 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5940 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
5941 },
5942 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5943 _bitfield_align_1: [],
5944 _bitfield_1: __BindgenBitfieldUnit::new(
5945 new_jsjitinfo_bitfield_1!(
5946 JSJitInfo_OpType::Method as u8,
5947 JSJitInfo_AliasSet::AliasEverything as u8,
5948 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5949 false,
5950 false,
5951 false,
5952 false,
5953 false,
5954 false,
5955 0,
5956 ).to_ne_bytes()
5957 ),
5958});
5959}
5960unsafe extern "C" fn getSyncParameter<D: DomTypes>
5961(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5962 let mut result = false;
5963 wrap_panic(&mut || result = (|| {
5964 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5965 let this = &*(this as *const D::WebGL2RenderingContext);
5966 let args = &*args;
5967 let argc = args.argc_;
5968
5969 if argc < 2 {
5970 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getSyncParameter\".");
5971 return false;
5972 }
5973 let arg0: DomRoot<D::WebGLSync> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5974 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5975 Ok(val) => val,
5976 Err(()) => {
5977 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLSync.");
5978 return false;
5979
5980 }
5981 }
5982
5983 } else {
5984 throw_type_error(cx.raw_cx(), "Value is not an object.");
5985 return false;
5986
5987 };
5988 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5989 Ok(ConversionResult::Success(value)) => value,
5990 Ok(ConversionResult::Failure(error)) => {
5991 throw_type_error(cx.raw_cx(), &error);
5992 return false;
5993
5994 }
5995 _ => {
5996 return false;
5997
5998 },
5999 }
6000 ;
6001 rooted!(&in(cx) let mut retval: JSVal);
6002 let result: () = this.GetSyncParameter(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, retval.handle_mut());
6003
6004 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6005 return true;
6006 })());
6007 result
6008}
6009
6010
6011static getSyncParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6012
6013pub(crate) fn init_getSyncParameter_methodinfo<D: DomTypes>() {
6014 getSyncParameter_methodinfo.set(JSJitInfo {
6015 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6016 method: Some(getSyncParameter::<D>)
6017 },
6018 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6019 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6020 },
6021 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6022 _bitfield_align_1: [],
6023 _bitfield_1: __BindgenBitfieldUnit::new(
6024 new_jsjitinfo_bitfield_1!(
6025 JSJitInfo_OpType::Method as u8,
6026 JSJitInfo_AliasSet::AliasEverything as u8,
6027 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6028 false,
6029 false,
6030 false,
6031 false,
6032 false,
6033 false,
6034 0,
6035 ).to_ne_bytes()
6036 ),
6037});
6038}
6039unsafe extern "C" fn createTransformFeedback<D: DomTypes>
6040(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6041 let mut result = false;
6042 wrap_panic(&mut || result = (|| {
6043 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6044 let this = &*(this as *const D::WebGL2RenderingContext);
6045 let args = &*args;
6046 let argc = args.argc_;
6047 let result: Option<DomRoot<D::WebGLTransformFeedback>> = this.CreateTransformFeedback();
6048
6049 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6050 return true;
6051 })());
6052 result
6053}
6054
6055
6056static createTransformFeedback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6057
6058pub(crate) fn init_createTransformFeedback_methodinfo<D: DomTypes>() {
6059 createTransformFeedback_methodinfo.set(JSJitInfo {
6060 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6061 method: Some(createTransformFeedback::<D>)
6062 },
6063 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6064 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6065 },
6066 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6067 _bitfield_align_1: [],
6068 _bitfield_1: __BindgenBitfieldUnit::new(
6069 new_jsjitinfo_bitfield_1!(
6070 JSJitInfo_OpType::Method as u8,
6071 JSJitInfo_AliasSet::AliasEverything as u8,
6072 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6073 true,
6074 false,
6075 false,
6076 false,
6077 false,
6078 false,
6079 0,
6080 ).to_ne_bytes()
6081 ),
6082});
6083}
6084unsafe extern "C" fn deleteTransformFeedback<D: DomTypes>
6085(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6086 let mut result = false;
6087 wrap_panic(&mut || result = (|| {
6088 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6089 let this = &*(this as *const D::WebGL2RenderingContext);
6090 let args = &*args;
6091 let argc = args.argc_;
6092
6093 if argc < 1 {
6094 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteTransformFeedback\".");
6095 return false;
6096 }
6097 let arg0: Option<DomRoot<D::WebGLTransformFeedback>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6098 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6099 Ok(val) => val,
6100 Err(()) => {
6101 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTransformFeedback.");
6102 return false;
6103
6104 }
6105 }
6106 )
6107 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
6108 None
6109 } else {
6110 throw_type_error(cx.raw_cx(), "Value is not an object.");
6111 return false;
6112
6113 };
6114 let result: () = this.DeleteTransformFeedback(arg0.as_deref());
6115
6116 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6117 return true;
6118 })());
6119 result
6120}
6121
6122
6123static deleteTransformFeedback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6124
6125pub(crate) fn init_deleteTransformFeedback_methodinfo<D: DomTypes>() {
6126 deleteTransformFeedback_methodinfo.set(JSJitInfo {
6127 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6128 method: Some(deleteTransformFeedback::<D>)
6129 },
6130 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6131 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6132 },
6133 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6134 _bitfield_align_1: [],
6135 _bitfield_1: __BindgenBitfieldUnit::new(
6136 new_jsjitinfo_bitfield_1!(
6137 JSJitInfo_OpType::Method as u8,
6138 JSJitInfo_AliasSet::AliasEverything as u8,
6139 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6140 false,
6141 false,
6142 false,
6143 false,
6144 false,
6145 false,
6146 0,
6147 ).to_ne_bytes()
6148 ),
6149});
6150}
6151unsafe extern "C" fn isTransformFeedback<D: DomTypes>
6152(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6153 let mut result = false;
6154 wrap_panic(&mut || result = (|| {
6155 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6156 let this = &*(this as *const D::WebGL2RenderingContext);
6157 let args = &*args;
6158 let argc = args.argc_;
6159
6160 if argc < 1 {
6161 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isTransformFeedback\".");
6162 return false;
6163 }
6164 let arg0: Option<DomRoot<D::WebGLTransformFeedback>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6165 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6166 Ok(val) => val,
6167 Err(()) => {
6168 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTransformFeedback.");
6169 return false;
6170
6171 }
6172 }
6173 )
6174 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
6175 None
6176 } else {
6177 throw_type_error(cx.raw_cx(), "Value is not an object.");
6178 return false;
6179
6180 };
6181 let result: bool = this.IsTransformFeedback(arg0.as_deref());
6182
6183 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6184 return true;
6185 })());
6186 result
6187}
6188
6189
6190static isTransformFeedback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6191
6192pub(crate) fn init_isTransformFeedback_methodinfo<D: DomTypes>() {
6193 isTransformFeedback_methodinfo.set(JSJitInfo {
6194 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6195 method: Some(isTransformFeedback::<D>)
6196 },
6197 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6198 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6199 },
6200 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6201 _bitfield_align_1: [],
6202 _bitfield_1: __BindgenBitfieldUnit::new(
6203 new_jsjitinfo_bitfield_1!(
6204 JSJitInfo_OpType::Method as u8,
6205 JSJitInfo_AliasSet::AliasEverything as u8,
6206 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
6207 false,
6208 false,
6209 false,
6210 false,
6211 false,
6212 false,
6213 0,
6214 ).to_ne_bytes()
6215 ),
6216});
6217}
6218unsafe extern "C" fn bindTransformFeedback<D: DomTypes>
6219(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6220 let mut result = false;
6221 wrap_panic(&mut || result = (|| {
6222 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6223 let this = &*(this as *const D::WebGL2RenderingContext);
6224 let args = &*args;
6225 let argc = args.argc_;
6226
6227 if argc < 2 {
6228 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindTransformFeedback\".");
6229 return false;
6230 }
6231 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6232 Ok(ConversionResult::Success(value)) => value,
6233 Ok(ConversionResult::Failure(error)) => {
6234 throw_type_error(cx.raw_cx(), &error);
6235 return false;
6236
6237 }
6238 _ => {
6239 return false;
6240
6241 },
6242 }
6243 ;
6244 let arg1: Option<DomRoot<D::WebGLTransformFeedback>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
6245 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
6246 Ok(val) => val,
6247 Err(()) => {
6248 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTransformFeedback.");
6249 return false;
6250
6251 }
6252 }
6253 )
6254 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
6255 None
6256 } else {
6257 throw_type_error(cx.raw_cx(), "Value is not an object.");
6258 return false;
6259
6260 };
6261 let result: () = this.BindTransformFeedback(arg0, arg1.as_deref());
6262
6263 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6264 return true;
6265 })());
6266 result
6267}
6268
6269
6270static bindTransformFeedback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6271
6272pub(crate) fn init_bindTransformFeedback_methodinfo<D: DomTypes>() {
6273 bindTransformFeedback_methodinfo.set(JSJitInfo {
6274 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6275 method: Some(bindTransformFeedback::<D>)
6276 },
6277 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6278 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6279 },
6280 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6281 _bitfield_align_1: [],
6282 _bitfield_1: __BindgenBitfieldUnit::new(
6283 new_jsjitinfo_bitfield_1!(
6284 JSJitInfo_OpType::Method as u8,
6285 JSJitInfo_AliasSet::AliasEverything as u8,
6286 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6287 false,
6288 false,
6289 false,
6290 false,
6291 false,
6292 false,
6293 0,
6294 ).to_ne_bytes()
6295 ),
6296});
6297}
6298unsafe extern "C" fn beginTransformFeedback<D: DomTypes>
6299(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6300 let mut result = false;
6301 wrap_panic(&mut || result = (|| {
6302 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6303 let this = &*(this as *const D::WebGL2RenderingContext);
6304 let args = &*args;
6305 let argc = args.argc_;
6306
6307 if argc < 1 {
6308 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.beginTransformFeedback\".");
6309 return false;
6310 }
6311 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6312 Ok(ConversionResult::Success(value)) => value,
6313 Ok(ConversionResult::Failure(error)) => {
6314 throw_type_error(cx.raw_cx(), &error);
6315 return false;
6316
6317 }
6318 _ => {
6319 return false;
6320
6321 },
6322 }
6323 ;
6324 let result: () = this.BeginTransformFeedback(arg0);
6325
6326 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6327 return true;
6328 })());
6329 result
6330}
6331
6332
6333static beginTransformFeedback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6334
6335pub(crate) fn init_beginTransformFeedback_methodinfo<D: DomTypes>() {
6336 beginTransformFeedback_methodinfo.set(JSJitInfo {
6337 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6338 method: Some(beginTransformFeedback::<D>)
6339 },
6340 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6341 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6342 },
6343 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6344 _bitfield_align_1: [],
6345 _bitfield_1: __BindgenBitfieldUnit::new(
6346 new_jsjitinfo_bitfield_1!(
6347 JSJitInfo_OpType::Method as u8,
6348 JSJitInfo_AliasSet::AliasEverything as u8,
6349 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6350 false,
6351 false,
6352 false,
6353 false,
6354 false,
6355 false,
6356 0,
6357 ).to_ne_bytes()
6358 ),
6359});
6360}
6361unsafe extern "C" fn endTransformFeedback<D: DomTypes>
6362(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6363 let mut result = false;
6364 wrap_panic(&mut || result = (|| {
6365 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6366 let this = &*(this as *const D::WebGL2RenderingContext);
6367 let args = &*args;
6368 let argc = args.argc_;
6369 let result: () = this.EndTransformFeedback();
6370
6371 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6372 return true;
6373 })());
6374 result
6375}
6376
6377
6378static endTransformFeedback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6379
6380pub(crate) fn init_endTransformFeedback_methodinfo<D: DomTypes>() {
6381 endTransformFeedback_methodinfo.set(JSJitInfo {
6382 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6383 method: Some(endTransformFeedback::<D>)
6384 },
6385 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6386 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6387 },
6388 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6389 _bitfield_align_1: [],
6390 _bitfield_1: __BindgenBitfieldUnit::new(
6391 new_jsjitinfo_bitfield_1!(
6392 JSJitInfo_OpType::Method as u8,
6393 JSJitInfo_AliasSet::AliasEverything as u8,
6394 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6395 true,
6396 false,
6397 false,
6398 false,
6399 false,
6400 false,
6401 0,
6402 ).to_ne_bytes()
6403 ),
6404});
6405}
6406unsafe extern "C" fn transformFeedbackVaryings<D: DomTypes>
6407(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6408 let mut result = false;
6409 wrap_panic(&mut || result = (|| {
6410 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6411 let this = &*(this as *const D::WebGL2RenderingContext);
6412 let args = &*args;
6413 let argc = args.argc_;
6414
6415 if argc < 3 {
6416 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.transformFeedbackVaryings\".");
6417 return false;
6418 }
6419 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6420 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6421 Ok(val) => val,
6422 Err(()) => {
6423 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
6424 return false;
6425
6426 }
6427 }
6428
6429 } else {
6430 throw_type_error(cx.raw_cx(), "Value is not an object.");
6431 return false;
6432
6433 };
6434 let arg1: Vec<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
6435 Ok(ConversionResult::Success(value)) => value,
6436 Ok(ConversionResult::Failure(error)) => {
6437 throw_type_error(cx.raw_cx(), &error);
6438 return false;
6439
6440 }
6441 _ => {
6442 return false;
6443
6444 },
6445 }
6446 ;
6447 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
6448 Ok(ConversionResult::Success(value)) => value,
6449 Ok(ConversionResult::Failure(error)) => {
6450 throw_type_error(cx.raw_cx(), &error);
6451 return false;
6452
6453 }
6454 _ => {
6455 return false;
6456
6457 },
6458 }
6459 ;
6460 let result: () = this.TransformFeedbackVaryings(&arg0, arg1, arg2);
6461
6462 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6463 return true;
6464 })());
6465 result
6466}
6467
6468
6469static transformFeedbackVaryings_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6470
6471pub(crate) fn init_transformFeedbackVaryings_methodinfo<D: DomTypes>() {
6472 transformFeedbackVaryings_methodinfo.set(JSJitInfo {
6473 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6474 method: Some(transformFeedbackVaryings::<D>)
6475 },
6476 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6477 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6478 },
6479 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6480 _bitfield_align_1: [],
6481 _bitfield_1: __BindgenBitfieldUnit::new(
6482 new_jsjitinfo_bitfield_1!(
6483 JSJitInfo_OpType::Method as u8,
6484 JSJitInfo_AliasSet::AliasEverything as u8,
6485 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6486 false,
6487 false,
6488 false,
6489 false,
6490 false,
6491 false,
6492 0,
6493 ).to_ne_bytes()
6494 ),
6495});
6496}
6497unsafe extern "C" fn getTransformFeedbackVarying<D: DomTypes>
6498(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6499 let mut result = false;
6500 wrap_panic(&mut || result = (|| {
6501 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6502 let this = &*(this as *const D::WebGL2RenderingContext);
6503 let args = &*args;
6504 let argc = args.argc_;
6505
6506 if argc < 2 {
6507 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getTransformFeedbackVarying\".");
6508 return false;
6509 }
6510 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6511 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6512 Ok(val) => val,
6513 Err(()) => {
6514 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
6515 return false;
6516
6517 }
6518 }
6519
6520 } else {
6521 throw_type_error(cx.raw_cx(), "Value is not an object.");
6522 return false;
6523
6524 };
6525 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
6526 Ok(ConversionResult::Success(value)) => value,
6527 Ok(ConversionResult::Failure(error)) => {
6528 throw_type_error(cx.raw_cx(), &error);
6529 return false;
6530
6531 }
6532 _ => {
6533 return false;
6534
6535 },
6536 }
6537 ;
6538 let result: Option<DomRoot<D::WebGLActiveInfo>> = this.GetTransformFeedbackVarying(&arg0, arg1);
6539
6540 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6541 return true;
6542 })());
6543 result
6544}
6545
6546
6547static getTransformFeedbackVarying_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6548
6549pub(crate) fn init_getTransformFeedbackVarying_methodinfo<D: DomTypes>() {
6550 getTransformFeedbackVarying_methodinfo.set(JSJitInfo {
6551 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6552 method: Some(getTransformFeedbackVarying::<D>)
6553 },
6554 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6555 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6556 },
6557 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6558 _bitfield_align_1: [],
6559 _bitfield_1: __BindgenBitfieldUnit::new(
6560 new_jsjitinfo_bitfield_1!(
6561 JSJitInfo_OpType::Method as u8,
6562 JSJitInfo_AliasSet::AliasEverything as u8,
6563 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6564 false,
6565 false,
6566 false,
6567 false,
6568 false,
6569 false,
6570 0,
6571 ).to_ne_bytes()
6572 ),
6573});
6574}
6575unsafe extern "C" fn pauseTransformFeedback<D: DomTypes>
6576(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6577 let mut result = false;
6578 wrap_panic(&mut || result = (|| {
6579 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6580 let this = &*(this as *const D::WebGL2RenderingContext);
6581 let args = &*args;
6582 let argc = args.argc_;
6583 let result: () = this.PauseTransformFeedback();
6584
6585 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6586 return true;
6587 })());
6588 result
6589}
6590
6591
6592static pauseTransformFeedback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6593
6594pub(crate) fn init_pauseTransformFeedback_methodinfo<D: DomTypes>() {
6595 pauseTransformFeedback_methodinfo.set(JSJitInfo {
6596 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6597 method: Some(pauseTransformFeedback::<D>)
6598 },
6599 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6600 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6601 },
6602 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6603 _bitfield_align_1: [],
6604 _bitfield_1: __BindgenBitfieldUnit::new(
6605 new_jsjitinfo_bitfield_1!(
6606 JSJitInfo_OpType::Method as u8,
6607 JSJitInfo_AliasSet::AliasEverything as u8,
6608 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6609 true,
6610 false,
6611 false,
6612 false,
6613 false,
6614 false,
6615 0,
6616 ).to_ne_bytes()
6617 ),
6618});
6619}
6620unsafe extern "C" fn resumeTransformFeedback<D: DomTypes>
6621(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6622 let mut result = false;
6623 wrap_panic(&mut || result = (|| {
6624 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6625 let this = &*(this as *const D::WebGL2RenderingContext);
6626 let args = &*args;
6627 let argc = args.argc_;
6628 let result: () = this.ResumeTransformFeedback();
6629
6630 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6631 return true;
6632 })());
6633 result
6634}
6635
6636
6637static resumeTransformFeedback_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6638
6639pub(crate) fn init_resumeTransformFeedback_methodinfo<D: DomTypes>() {
6640 resumeTransformFeedback_methodinfo.set(JSJitInfo {
6641 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6642 method: Some(resumeTransformFeedback::<D>)
6643 },
6644 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6645 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6646 },
6647 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6648 _bitfield_align_1: [],
6649 _bitfield_1: __BindgenBitfieldUnit::new(
6650 new_jsjitinfo_bitfield_1!(
6651 JSJitInfo_OpType::Method as u8,
6652 JSJitInfo_AliasSet::AliasEverything as u8,
6653 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6654 true,
6655 false,
6656 false,
6657 false,
6658 false,
6659 false,
6660 0,
6661 ).to_ne_bytes()
6662 ),
6663});
6664}
6665unsafe extern "C" fn bindBufferBase<D: DomTypes>
6666(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6667 let mut result = false;
6668 wrap_panic(&mut || result = (|| {
6669 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6670 let this = &*(this as *const D::WebGL2RenderingContext);
6671 let args = &*args;
6672 let argc = args.argc_;
6673
6674 if argc < 3 {
6675 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindBufferBase\".");
6676 return false;
6677 }
6678 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6679 Ok(ConversionResult::Success(value)) => value,
6680 Ok(ConversionResult::Failure(error)) => {
6681 throw_type_error(cx.raw_cx(), &error);
6682 return false;
6683
6684 }
6685 _ => {
6686 return false;
6687
6688 },
6689 }
6690 ;
6691 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
6692 Ok(ConversionResult::Success(value)) => value,
6693 Ok(ConversionResult::Failure(error)) => {
6694 throw_type_error(cx.raw_cx(), &error);
6695 return false;
6696
6697 }
6698 _ => {
6699 return false;
6700
6701 },
6702 }
6703 ;
6704 let arg2: Option<DomRoot<D::WebGLBuffer>> = if HandleValue::from_raw(args.get(2)).get().is_object() {
6705 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(2)), SafeJSContext::from_ptr(cx.raw_cx())) {
6706 Ok(val) => val,
6707 Err(()) => {
6708 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLBuffer.");
6709 return false;
6710
6711 }
6712 }
6713 )
6714 } else if HandleValue::from_raw(args.get(2)).get().is_null_or_undefined() {
6715 None
6716 } else {
6717 throw_type_error(cx.raw_cx(), "Value is not an object.");
6718 return false;
6719
6720 };
6721 let result: () = this.BindBufferBase(arg0, arg1, arg2.as_deref());
6722
6723 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6724 return true;
6725 })());
6726 result
6727}
6728
6729
6730static bindBufferBase_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6731
6732pub(crate) fn init_bindBufferBase_methodinfo<D: DomTypes>() {
6733 bindBufferBase_methodinfo.set(JSJitInfo {
6734 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6735 method: Some(bindBufferBase::<D>)
6736 },
6737 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6738 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6739 },
6740 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6741 _bitfield_align_1: [],
6742 _bitfield_1: __BindgenBitfieldUnit::new(
6743 new_jsjitinfo_bitfield_1!(
6744 JSJitInfo_OpType::Method as u8,
6745 JSJitInfo_AliasSet::AliasEverything as u8,
6746 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6747 false,
6748 false,
6749 false,
6750 false,
6751 false,
6752 false,
6753 0,
6754 ).to_ne_bytes()
6755 ),
6756});
6757}
6758unsafe extern "C" fn bindBufferRange<D: DomTypes>
6759(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6760 let mut result = false;
6761 wrap_panic(&mut || result = (|| {
6762 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6763 let this = &*(this as *const D::WebGL2RenderingContext);
6764 let args = &*args;
6765 let argc = args.argc_;
6766
6767 if argc < 5 {
6768 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindBufferRange\".");
6769 return false;
6770 }
6771 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6772 Ok(ConversionResult::Success(value)) => value,
6773 Ok(ConversionResult::Failure(error)) => {
6774 throw_type_error(cx.raw_cx(), &error);
6775 return false;
6776
6777 }
6778 _ => {
6779 return false;
6780
6781 },
6782 }
6783 ;
6784 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
6785 Ok(ConversionResult::Success(value)) => value,
6786 Ok(ConversionResult::Failure(error)) => {
6787 throw_type_error(cx.raw_cx(), &error);
6788 return false;
6789
6790 }
6791 _ => {
6792 return false;
6793
6794 },
6795 }
6796 ;
6797 let arg2: Option<DomRoot<D::WebGLBuffer>> = if HandleValue::from_raw(args.get(2)).get().is_object() {
6798 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(2)), SafeJSContext::from_ptr(cx.raw_cx())) {
6799 Ok(val) => val,
6800 Err(()) => {
6801 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLBuffer.");
6802 return false;
6803
6804 }
6805 }
6806 )
6807 } else if HandleValue::from_raw(args.get(2)).get().is_null_or_undefined() {
6808 None
6809 } else {
6810 throw_type_error(cx.raw_cx(), "Value is not an object.");
6811 return false;
6812
6813 };
6814 let arg3: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
6815 Ok(ConversionResult::Success(value)) => value,
6816 Ok(ConversionResult::Failure(error)) => {
6817 throw_type_error(cx.raw_cx(), &error);
6818 return false;
6819
6820 }
6821 _ => {
6822 return false;
6823
6824 },
6825 }
6826 ;
6827 let arg4: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
6828 Ok(ConversionResult::Success(value)) => value,
6829 Ok(ConversionResult::Failure(error)) => {
6830 throw_type_error(cx.raw_cx(), &error);
6831 return false;
6832
6833 }
6834 _ => {
6835 return false;
6836
6837 },
6838 }
6839 ;
6840 let result: () = this.BindBufferRange(arg0, arg1, arg2.as_deref(), arg3, arg4);
6841
6842 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6843 return true;
6844 })());
6845 result
6846}
6847
6848
6849static bindBufferRange_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6850
6851pub(crate) fn init_bindBufferRange_methodinfo<D: DomTypes>() {
6852 bindBufferRange_methodinfo.set(JSJitInfo {
6853 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6854 method: Some(bindBufferRange::<D>)
6855 },
6856 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6857 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6858 },
6859 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6860 _bitfield_align_1: [],
6861 _bitfield_1: __BindgenBitfieldUnit::new(
6862 new_jsjitinfo_bitfield_1!(
6863 JSJitInfo_OpType::Method as u8,
6864 JSJitInfo_AliasSet::AliasEverything as u8,
6865 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6866 false,
6867 false,
6868 false,
6869 false,
6870 false,
6871 false,
6872 0,
6873 ).to_ne_bytes()
6874 ),
6875});
6876}
6877unsafe extern "C" fn getIndexedParameter<D: DomTypes>
6878(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6879 let mut result = false;
6880 wrap_panic(&mut || result = (|| {
6881 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6882 let this = &*(this as *const D::WebGL2RenderingContext);
6883 let args = &*args;
6884 let argc = args.argc_;
6885
6886 if argc < 2 {
6887 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getIndexedParameter\".");
6888 return false;
6889 }
6890 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6891 Ok(ConversionResult::Success(value)) => value,
6892 Ok(ConversionResult::Failure(error)) => {
6893 throw_type_error(cx.raw_cx(), &error);
6894 return false;
6895
6896 }
6897 _ => {
6898 return false;
6899
6900 },
6901 }
6902 ;
6903 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
6904 Ok(ConversionResult::Success(value)) => value,
6905 Ok(ConversionResult::Failure(error)) => {
6906 throw_type_error(cx.raw_cx(), &error);
6907 return false;
6908
6909 }
6910 _ => {
6911 return false;
6912
6913 },
6914 }
6915 ;
6916 rooted!(&in(cx) let mut retval: JSVal);
6917 let result: () = this.GetIndexedParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
6918
6919 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6920 return true;
6921 })());
6922 result
6923}
6924
6925
6926static getIndexedParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6927
6928pub(crate) fn init_getIndexedParameter_methodinfo<D: DomTypes>() {
6929 getIndexedParameter_methodinfo.set(JSJitInfo {
6930 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6931 method: Some(getIndexedParameter::<D>)
6932 },
6933 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6934 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
6935 },
6936 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6937 _bitfield_align_1: [],
6938 _bitfield_1: __BindgenBitfieldUnit::new(
6939 new_jsjitinfo_bitfield_1!(
6940 JSJitInfo_OpType::Method as u8,
6941 JSJitInfo_AliasSet::AliasEverything as u8,
6942 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6943 false,
6944 false,
6945 false,
6946 false,
6947 false,
6948 false,
6949 0,
6950 ).to_ne_bytes()
6951 ),
6952});
6953}
6954unsafe extern "C" fn getUniformIndices<D: DomTypes>
6955(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6956 let mut result = false;
6957 wrap_panic(&mut || result = (|| {
6958 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6959 let this = &*(this as *const D::WebGL2RenderingContext);
6960 let args = &*args;
6961 let argc = args.argc_;
6962
6963 if argc < 2 {
6964 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getUniformIndices\".");
6965 return false;
6966 }
6967 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6968 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6969 Ok(val) => val,
6970 Err(()) => {
6971 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
6972 return false;
6973
6974 }
6975 }
6976
6977 } else {
6978 throw_type_error(cx.raw_cx(), "Value is not an object.");
6979 return false;
6980
6981 };
6982 let arg1: Vec<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
6983 Ok(ConversionResult::Success(value)) => value,
6984 Ok(ConversionResult::Failure(error)) => {
6985 throw_type_error(cx.raw_cx(), &error);
6986 return false;
6987
6988 }
6989 _ => {
6990 return false;
6991
6992 },
6993 }
6994 ;
6995 let result: Option<Vec<u32>> = this.GetUniformIndices(&arg0, arg1);
6996
6997 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6998 return true;
6999 })());
7000 result
7001}
7002
7003
7004static getUniformIndices_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7005
7006pub(crate) fn init_getUniformIndices_methodinfo<D: DomTypes>() {
7007 getUniformIndices_methodinfo.set(JSJitInfo {
7008 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7009 method: Some(getUniformIndices::<D>)
7010 },
7011 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7012 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7013 },
7014 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7015 _bitfield_align_1: [],
7016 _bitfield_1: __BindgenBitfieldUnit::new(
7017 new_jsjitinfo_bitfield_1!(
7018 JSJitInfo_OpType::Method as u8,
7019 JSJitInfo_AliasSet::AliasEverything as u8,
7020 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7021 false,
7022 false,
7023 false,
7024 false,
7025 false,
7026 false,
7027 0,
7028 ).to_ne_bytes()
7029 ),
7030});
7031}
7032unsafe extern "C" fn getActiveUniforms<D: DomTypes>
7033(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7034 let mut result = false;
7035 wrap_panic(&mut || result = (|| {
7036 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7037 let this = &*(this as *const D::WebGL2RenderingContext);
7038 let args = &*args;
7039 let argc = args.argc_;
7040
7041 if argc < 3 {
7042 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getActiveUniforms\".");
7043 return false;
7044 }
7045 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7046 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7047 Ok(val) => val,
7048 Err(()) => {
7049 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
7050 return false;
7051
7052 }
7053 }
7054
7055 } else {
7056 throw_type_error(cx.raw_cx(), "Value is not an object.");
7057 return false;
7058
7059 };
7060 let arg1: Vec<u32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7061 Ok(ConversionResult::Success(value)) => value,
7062 Ok(ConversionResult::Failure(error)) => {
7063 throw_type_error(cx.raw_cx(), &error);
7064 return false;
7065
7066 }
7067 _ => {
7068 return false;
7069
7070 },
7071 }
7072 ;
7073 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7074 Ok(ConversionResult::Success(value)) => value,
7075 Ok(ConversionResult::Failure(error)) => {
7076 throw_type_error(cx.raw_cx(), &error);
7077 return false;
7078
7079 }
7080 _ => {
7081 return false;
7082
7083 },
7084 }
7085 ;
7086 rooted!(&in(cx) let mut retval: JSVal);
7087 let result: () = this.GetActiveUniforms(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, arg2, retval.handle_mut());
7088
7089 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7090 return true;
7091 })());
7092 result
7093}
7094
7095
7096static getActiveUniforms_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7097
7098pub(crate) fn init_getActiveUniforms_methodinfo<D: DomTypes>() {
7099 getActiveUniforms_methodinfo.set(JSJitInfo {
7100 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7101 method: Some(getActiveUniforms::<D>)
7102 },
7103 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7104 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7105 },
7106 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7107 _bitfield_align_1: [],
7108 _bitfield_1: __BindgenBitfieldUnit::new(
7109 new_jsjitinfo_bitfield_1!(
7110 JSJitInfo_OpType::Method as u8,
7111 JSJitInfo_AliasSet::AliasEverything as u8,
7112 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7113 false,
7114 false,
7115 false,
7116 false,
7117 false,
7118 false,
7119 0,
7120 ).to_ne_bytes()
7121 ),
7122});
7123}
7124unsafe extern "C" fn getUniformBlockIndex<D: DomTypes>
7125(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7126 let mut result = false;
7127 wrap_panic(&mut || result = (|| {
7128 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7129 let this = &*(this as *const D::WebGL2RenderingContext);
7130 let args = &*args;
7131 let argc = args.argc_;
7132
7133 if argc < 2 {
7134 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getUniformBlockIndex\".");
7135 return false;
7136 }
7137 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7138 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7139 Ok(val) => val,
7140 Err(()) => {
7141 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
7142 return false;
7143
7144 }
7145 }
7146
7147 } else {
7148 throw_type_error(cx.raw_cx(), "Value is not an object.");
7149 return false;
7150
7151 };
7152 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
7153 Ok(ConversionResult::Success(value)) => value,
7154 Ok(ConversionResult::Failure(error)) => {
7155 throw_type_error(cx.raw_cx(), &error);
7156 return false;
7157
7158 }
7159 _ => {
7160 return false;
7161
7162 },
7163 }
7164 ;
7165 let result: u32 = this.GetUniformBlockIndex(&arg0, arg1);
7166
7167 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7168 return true;
7169 })());
7170 result
7171}
7172
7173
7174static getUniformBlockIndex_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7175
7176pub(crate) fn init_getUniformBlockIndex_methodinfo<D: DomTypes>() {
7177 getUniformBlockIndex_methodinfo.set(JSJitInfo {
7178 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7179 method: Some(getUniformBlockIndex::<D>)
7180 },
7181 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7182 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7183 },
7184 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7185 _bitfield_align_1: [],
7186 _bitfield_1: __BindgenBitfieldUnit::new(
7187 new_jsjitinfo_bitfield_1!(
7188 JSJitInfo_OpType::Method as u8,
7189 JSJitInfo_AliasSet::AliasEverything as u8,
7190 JSValueType::JSVAL_TYPE_DOUBLE as u8,
7191 false,
7192 false,
7193 false,
7194 false,
7195 false,
7196 false,
7197 0,
7198 ).to_ne_bytes()
7199 ),
7200});
7201}
7202unsafe extern "C" fn getActiveUniformBlockParameter<D: DomTypes>
7203(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7204 let mut result = false;
7205 wrap_panic(&mut || result = (|| {
7206 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7207 let this = &*(this as *const D::WebGL2RenderingContext);
7208 let args = &*args;
7209 let argc = args.argc_;
7210
7211 if argc < 3 {
7212 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getActiveUniformBlockParameter\".");
7213 return false;
7214 }
7215 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7216 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7217 Ok(val) => val,
7218 Err(()) => {
7219 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
7220 return false;
7221
7222 }
7223 }
7224
7225 } else {
7226 throw_type_error(cx.raw_cx(), "Value is not an object.");
7227 return false;
7228
7229 };
7230 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7231 Ok(ConversionResult::Success(value)) => value,
7232 Ok(ConversionResult::Failure(error)) => {
7233 throw_type_error(cx.raw_cx(), &error);
7234 return false;
7235
7236 }
7237 _ => {
7238 return false;
7239
7240 },
7241 }
7242 ;
7243 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7244 Ok(ConversionResult::Success(value)) => value,
7245 Ok(ConversionResult::Failure(error)) => {
7246 throw_type_error(cx.raw_cx(), &error);
7247 return false;
7248
7249 }
7250 _ => {
7251 return false;
7252
7253 },
7254 }
7255 ;
7256 rooted!(&in(cx) let mut retval: JSVal);
7257 let result: () = this.GetActiveUniformBlockParameter(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, arg2, retval.handle_mut());
7258
7259 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7260 return true;
7261 })());
7262 result
7263}
7264
7265
7266static getActiveUniformBlockParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7267
7268pub(crate) fn init_getActiveUniformBlockParameter_methodinfo<D: DomTypes>() {
7269 getActiveUniformBlockParameter_methodinfo.set(JSJitInfo {
7270 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7271 method: Some(getActiveUniformBlockParameter::<D>)
7272 },
7273 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7274 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7275 },
7276 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7277 _bitfield_align_1: [],
7278 _bitfield_1: __BindgenBitfieldUnit::new(
7279 new_jsjitinfo_bitfield_1!(
7280 JSJitInfo_OpType::Method as u8,
7281 JSJitInfo_AliasSet::AliasEverything as u8,
7282 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7283 false,
7284 false,
7285 false,
7286 false,
7287 false,
7288 false,
7289 0,
7290 ).to_ne_bytes()
7291 ),
7292});
7293}
7294unsafe extern "C" fn getActiveUniformBlockName<D: DomTypes>
7295(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7296 let mut result = false;
7297 wrap_panic(&mut || result = (|| {
7298 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7299 let this = &*(this as *const D::WebGL2RenderingContext);
7300 let args = &*args;
7301 let argc = args.argc_;
7302
7303 if argc < 2 {
7304 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getActiveUniformBlockName\".");
7305 return false;
7306 }
7307 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7308 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7309 Ok(val) => val,
7310 Err(()) => {
7311 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
7312 return false;
7313
7314 }
7315 }
7316
7317 } else {
7318 throw_type_error(cx.raw_cx(), "Value is not an object.");
7319 return false;
7320
7321 };
7322 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7323 Ok(ConversionResult::Success(value)) => value,
7324 Ok(ConversionResult::Failure(error)) => {
7325 throw_type_error(cx.raw_cx(), &error);
7326 return false;
7327
7328 }
7329 _ => {
7330 return false;
7331
7332 },
7333 }
7334 ;
7335 let result: Option<DOMString> = this.GetActiveUniformBlockName(&arg0, arg1);
7336
7337 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7338 return true;
7339 })());
7340 result
7341}
7342
7343
7344static getActiveUniformBlockName_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7345
7346pub(crate) fn init_getActiveUniformBlockName_methodinfo<D: DomTypes>() {
7347 getActiveUniformBlockName_methodinfo.set(JSJitInfo {
7348 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7349 method: Some(getActiveUniformBlockName::<D>)
7350 },
7351 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7352 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7353 },
7354 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7355 _bitfield_align_1: [],
7356 _bitfield_1: __BindgenBitfieldUnit::new(
7357 new_jsjitinfo_bitfield_1!(
7358 JSJitInfo_OpType::Method as u8,
7359 JSJitInfo_AliasSet::AliasEverything as u8,
7360 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7361 false,
7362 false,
7363 false,
7364 false,
7365 false,
7366 false,
7367 0,
7368 ).to_ne_bytes()
7369 ),
7370});
7371}
7372unsafe extern "C" fn uniformBlockBinding<D: DomTypes>
7373(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7374 let mut result = false;
7375 wrap_panic(&mut || result = (|| {
7376 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7377 let this = &*(this as *const D::WebGL2RenderingContext);
7378 let args = &*args;
7379 let argc = args.argc_;
7380
7381 if argc < 3 {
7382 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformBlockBinding\".");
7383 return false;
7384 }
7385 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7386 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7387 Ok(val) => val,
7388 Err(()) => {
7389 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
7390 return false;
7391
7392 }
7393 }
7394
7395 } else {
7396 throw_type_error(cx.raw_cx(), "Value is not an object.");
7397 return false;
7398
7399 };
7400 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7401 Ok(ConversionResult::Success(value)) => value,
7402 Ok(ConversionResult::Failure(error)) => {
7403 throw_type_error(cx.raw_cx(), &error);
7404 return false;
7405
7406 }
7407 _ => {
7408 return false;
7409
7410 },
7411 }
7412 ;
7413 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7414 Ok(ConversionResult::Success(value)) => value,
7415 Ok(ConversionResult::Failure(error)) => {
7416 throw_type_error(cx.raw_cx(), &error);
7417 return false;
7418
7419 }
7420 _ => {
7421 return false;
7422
7423 },
7424 }
7425 ;
7426 let result: () = this.UniformBlockBinding(&arg0, arg1, arg2);
7427
7428 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7429 return true;
7430 })());
7431 result
7432}
7433
7434
7435static uniformBlockBinding_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7436
7437pub(crate) fn init_uniformBlockBinding_methodinfo<D: DomTypes>() {
7438 uniformBlockBinding_methodinfo.set(JSJitInfo {
7439 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7440 method: Some(uniformBlockBinding::<D>)
7441 },
7442 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7443 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7444 },
7445 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7446 _bitfield_align_1: [],
7447 _bitfield_1: __BindgenBitfieldUnit::new(
7448 new_jsjitinfo_bitfield_1!(
7449 JSJitInfo_OpType::Method as u8,
7450 JSJitInfo_AliasSet::AliasEverything as u8,
7451 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7452 false,
7453 false,
7454 false,
7455 false,
7456 false,
7457 false,
7458 0,
7459 ).to_ne_bytes()
7460 ),
7461});
7462}
7463unsafe extern "C" fn createVertexArray<D: DomTypes>
7464(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7465 let mut result = false;
7466 wrap_panic(&mut || result = (|| {
7467 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7468 let this = &*(this as *const D::WebGL2RenderingContext);
7469 let args = &*args;
7470 let argc = args.argc_;
7471 let result: Option<DomRoot<D::WebGLVertexArrayObject>> = this.CreateVertexArray();
7472
7473 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7474 return true;
7475 })());
7476 result
7477}
7478
7479
7480static createVertexArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7481
7482pub(crate) fn init_createVertexArray_methodinfo<D: DomTypes>() {
7483 createVertexArray_methodinfo.set(JSJitInfo {
7484 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7485 method: Some(createVertexArray::<D>)
7486 },
7487 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7488 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7489 },
7490 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7491 _bitfield_align_1: [],
7492 _bitfield_1: __BindgenBitfieldUnit::new(
7493 new_jsjitinfo_bitfield_1!(
7494 JSJitInfo_OpType::Method as u8,
7495 JSJitInfo_AliasSet::AliasEverything as u8,
7496 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7497 true,
7498 false,
7499 false,
7500 false,
7501 false,
7502 false,
7503 0,
7504 ).to_ne_bytes()
7505 ),
7506});
7507}
7508unsafe extern "C" fn deleteVertexArray<D: DomTypes>
7509(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7510 let mut result = false;
7511 wrap_panic(&mut || result = (|| {
7512 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7513 let this = &*(this as *const D::WebGL2RenderingContext);
7514 let args = &*args;
7515 let argc = args.argc_;
7516
7517 if argc < 1 {
7518 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteVertexArray\".");
7519 return false;
7520 }
7521 let arg0: Option<DomRoot<D::WebGLVertexArrayObject>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7522 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7523 Ok(val) => val,
7524 Err(()) => {
7525 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLVertexArrayObject.");
7526 return false;
7527
7528 }
7529 }
7530 )
7531 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
7532 None
7533 } else {
7534 throw_type_error(cx.raw_cx(), "Value is not an object.");
7535 return false;
7536
7537 };
7538 let result: () = this.DeleteVertexArray(arg0.as_deref());
7539
7540 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7541 return true;
7542 })());
7543 result
7544}
7545
7546
7547static deleteVertexArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7548
7549pub(crate) fn init_deleteVertexArray_methodinfo<D: DomTypes>() {
7550 deleteVertexArray_methodinfo.set(JSJitInfo {
7551 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7552 method: Some(deleteVertexArray::<D>)
7553 },
7554 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7555 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7556 },
7557 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7558 _bitfield_align_1: [],
7559 _bitfield_1: __BindgenBitfieldUnit::new(
7560 new_jsjitinfo_bitfield_1!(
7561 JSJitInfo_OpType::Method as u8,
7562 JSJitInfo_AliasSet::AliasEverything as u8,
7563 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7564 false,
7565 false,
7566 false,
7567 false,
7568 false,
7569 false,
7570 0,
7571 ).to_ne_bytes()
7572 ),
7573});
7574}
7575unsafe extern "C" fn isVertexArray<D: DomTypes>
7576(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7577 let mut result = false;
7578 wrap_panic(&mut || result = (|| {
7579 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7580 let this = &*(this as *const D::WebGL2RenderingContext);
7581 let args = &*args;
7582 let argc = args.argc_;
7583
7584 if argc < 1 {
7585 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isVertexArray\".");
7586 return false;
7587 }
7588 let arg0: Option<DomRoot<D::WebGLVertexArrayObject>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7589 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7590 Ok(val) => val,
7591 Err(()) => {
7592 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLVertexArrayObject.");
7593 return false;
7594
7595 }
7596 }
7597 )
7598 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
7599 None
7600 } else {
7601 throw_type_error(cx.raw_cx(), "Value is not an object.");
7602 return false;
7603
7604 };
7605 let result: bool = this.IsVertexArray(arg0.as_deref());
7606
7607 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7608 return true;
7609 })());
7610 result
7611}
7612
7613
7614static isVertexArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7615
7616pub(crate) fn init_isVertexArray_methodinfo<D: DomTypes>() {
7617 isVertexArray_methodinfo.set(JSJitInfo {
7618 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7619 method: Some(isVertexArray::<D>)
7620 },
7621 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7622 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7623 },
7624 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7625 _bitfield_align_1: [],
7626 _bitfield_1: __BindgenBitfieldUnit::new(
7627 new_jsjitinfo_bitfield_1!(
7628 JSJitInfo_OpType::Method as u8,
7629 JSJitInfo_AliasSet::AliasEverything as u8,
7630 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
7631 false,
7632 false,
7633 false,
7634 false,
7635 false,
7636 false,
7637 0,
7638 ).to_ne_bytes()
7639 ),
7640});
7641}
7642unsafe extern "C" fn bindVertexArray<D: DomTypes>
7643(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7644 let mut result = false;
7645 wrap_panic(&mut || result = (|| {
7646 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7647 let this = &*(this as *const D::WebGL2RenderingContext);
7648 let args = &*args;
7649 let argc = args.argc_;
7650
7651 if argc < 1 {
7652 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindVertexArray\".");
7653 return false;
7654 }
7655 let arg0: Option<DomRoot<D::WebGLVertexArrayObject>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7656 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7657 Ok(val) => val,
7658 Err(()) => {
7659 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLVertexArrayObject.");
7660 return false;
7661
7662 }
7663 }
7664 )
7665 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
7666 None
7667 } else {
7668 throw_type_error(cx.raw_cx(), "Value is not an object.");
7669 return false;
7670
7671 };
7672 let result: () = this.BindVertexArray(arg0.as_deref());
7673
7674 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7675 return true;
7676 })());
7677 result
7678}
7679
7680
7681static bindVertexArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7682
7683pub(crate) fn init_bindVertexArray_methodinfo<D: DomTypes>() {
7684 bindVertexArray_methodinfo.set(JSJitInfo {
7685 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7686 method: Some(bindVertexArray::<D>)
7687 },
7688 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7689 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
7690 },
7691 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7692 _bitfield_align_1: [],
7693 _bitfield_1: __BindgenBitfieldUnit::new(
7694 new_jsjitinfo_bitfield_1!(
7695 JSJitInfo_OpType::Method as u8,
7696 JSJitInfo_AliasSet::AliasEverything as u8,
7697 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7698 false,
7699 false,
7700 false,
7701 false,
7702 false,
7703 false,
7704 0,
7705 ).to_ne_bytes()
7706 ),
7707});
7708}
7709unsafe extern "C" fn bufferData<D: DomTypes>
7710(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7711 let mut result = false;
7712 wrap_panic(&mut || result = (|| {
7713 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7714 let this = &*(this as *const D::WebGL2RenderingContext);
7715 let args = &*args;
7716 let argc = args.argc_;
7717
7718 let argcount = cmp::min(argc, 5);
7719 match argcount {
7720 3 => {
7721 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7722 Ok(ConversionResult::Success(value)) => value,
7723 Ok(ConversionResult::Failure(error)) => {
7724 throw_type_error(cx.raw_cx(), &error);
7725 return false;
7726
7727 }
7728 _ => {
7729 return false;
7730
7731 },
7732 }
7733 ;
7734 if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
7735 let arg1: Option<GenericUnionTypes::ArrayBufferViewOrArrayBuffer > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
7736 Ok(ConversionResult::Success(value)) => value,
7737 Ok(ConversionResult::Failure(error)) => {
7738 throw_type_error(cx.raw_cx(), &error);
7739 return false;
7740
7741 }
7742 _ => {
7743 return false;
7744
7745 },
7746 }
7747 ;
7748 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7749 Ok(ConversionResult::Success(value)) => value,
7750 Ok(ConversionResult::Failure(error)) => {
7751 throw_type_error(cx.raw_cx(), &error);
7752 return false;
7753
7754 }
7755 _ => {
7756 return false;
7757
7758 },
7759 }
7760 ;
7761 let result: () = this.BufferData_(arg0, arg1, arg2);
7762
7763 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7764 return true;
7765 }
7766 if HandleValue::from_raw(args.get(1)).get().is_object() {
7767 '_block: {
7768 let arg1: Option<GenericUnionTypes::ArrayBufferViewOrArrayBuffer > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
7769 Ok(ConversionResult::Success(value)) => value,
7770 Ok(ConversionResult::Failure(error)) => {
7771 break '_block;
7772 }
7773 _ => {
7774 return false;
7775
7776 },
7777 }
7778 ;
7779 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7780 Ok(ConversionResult::Success(value)) => value,
7781 Ok(ConversionResult::Failure(error)) => {
7782 throw_type_error(cx.raw_cx(), &error);
7783 return false;
7784
7785 }
7786 _ => {
7787 return false;
7788
7789 },
7790 }
7791 ;
7792 let result: () = this.BufferData_(arg0, arg1, arg2);
7793
7794 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7795 return true;
7796 }
7797 }
7798 let arg1: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7799 Ok(ConversionResult::Success(value)) => value,
7800 Ok(ConversionResult::Failure(error)) => {
7801 throw_type_error(cx.raw_cx(), &error);
7802 return false;
7803
7804 }
7805 _ => {
7806 return false;
7807
7808 },
7809 }
7810 ;
7811 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7812 Ok(ConversionResult::Success(value)) => value,
7813 Ok(ConversionResult::Failure(error)) => {
7814 throw_type_error(cx.raw_cx(), &error);
7815 return false;
7816
7817 }
7818 _ => {
7819 return false;
7820
7821 },
7822 }
7823 ;
7824 let result: () = this.BufferData(arg0, arg1, arg2);
7825
7826 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7827 return true;
7828 }
7829 4 => {
7830 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7831 Ok(ConversionResult::Success(value)) => value,
7832 Ok(ConversionResult::Failure(error)) => {
7833 throw_type_error(cx.raw_cx(), &error);
7834 return false;
7835
7836 }
7837 _ => {
7838 return false;
7839
7840 },
7841 }
7842 ;
7843 let arg1: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(1)).get().is_object() {
7844 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(1)).get().to_object()) {
7845 Ok(val) => val,
7846 Err(()) => {
7847 throw_type_error(cx.raw_cx(), "value is not a typed array.");
7848 return false;
7849
7850 }
7851 }
7852
7853 } else {
7854 throw_type_error(cx.raw_cx(), "Value is not an object.");
7855 return false;
7856
7857 };
7858 auto_root!(&in(cx) let arg1 = arg1);
7859 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7860 Ok(ConversionResult::Success(value)) => value,
7861 Ok(ConversionResult::Failure(error)) => {
7862 throw_type_error(cx.raw_cx(), &error);
7863 return false;
7864
7865 }
7866 _ => {
7867 return false;
7868
7869 },
7870 }
7871 ;
7872 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
7873 Ok(ConversionResult::Success(value)) => value,
7874 Ok(ConversionResult::Failure(error)) => {
7875 throw_type_error(cx.raw_cx(), &error);
7876 return false;
7877
7878 }
7879 _ => {
7880 return false;
7881
7882 },
7883 }
7884 ;
7885 let arg4: u32 = if args.get(4).is_undefined() {
7886 0
7887 } else {
7888 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
7889 Ok(ConversionResult::Success(value)) => value,
7890 Ok(ConversionResult::Failure(error)) => {
7891 throw_type_error(cx.raw_cx(), &error);
7892 return false;
7893
7894 }
7895 _ => {
7896 return false;
7897
7898 },
7899 }
7900
7901 };
7902 let result: () = this.BufferData__(arg0, arg1, arg2, arg3, arg4);
7903
7904 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7905 return true;
7906 }
7907 5 => {
7908 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7909 Ok(ConversionResult::Success(value)) => value,
7910 Ok(ConversionResult::Failure(error)) => {
7911 throw_type_error(cx.raw_cx(), &error);
7912 return false;
7913
7914 }
7915 _ => {
7916 return false;
7917
7918 },
7919 }
7920 ;
7921 let arg1: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(1)).get().is_object() {
7922 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(1)).get().to_object()) {
7923 Ok(val) => val,
7924 Err(()) => {
7925 throw_type_error(cx.raw_cx(), "value is not a typed array.");
7926 return false;
7927
7928 }
7929 }
7930
7931 } else {
7932 throw_type_error(cx.raw_cx(), "Value is not an object.");
7933 return false;
7934
7935 };
7936 auto_root!(&in(cx) let arg1 = arg1);
7937 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7938 Ok(ConversionResult::Success(value)) => value,
7939 Ok(ConversionResult::Failure(error)) => {
7940 throw_type_error(cx.raw_cx(), &error);
7941 return false;
7942
7943 }
7944 _ => {
7945 return false;
7946
7947 },
7948 }
7949 ;
7950 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
7951 Ok(ConversionResult::Success(value)) => value,
7952 Ok(ConversionResult::Failure(error)) => {
7953 throw_type_error(cx.raw_cx(), &error);
7954 return false;
7955
7956 }
7957 _ => {
7958 return false;
7959
7960 },
7961 }
7962 ;
7963 let arg4: u32 = if args.get(4).is_undefined() {
7964 0
7965 } else {
7966 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
7967 Ok(ConversionResult::Success(value)) => value,
7968 Ok(ConversionResult::Failure(error)) => {
7969 throw_type_error(cx.raw_cx(), &error);
7970 return false;
7971
7972 }
7973 _ => {
7974 return false;
7975
7976 },
7977 }
7978
7979 };
7980 let result: () = this.BufferData__(arg0, arg1, arg2, arg3, arg4);
7981
7982 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7983 return true;
7984 }
7985 _ => {
7986 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bufferData\".");
7987 return false;
7988 }
7989 }
7990 })());
7991 result
7992}
7993
7994
7995static bufferData_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7996
7997pub(crate) fn init_bufferData_methodinfo<D: DomTypes>() {
7998 bufferData_methodinfo.set(JSJitInfo {
7999 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8000 method: Some(bufferData::<D>)
8001 },
8002 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8003 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
8004 },
8005 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8006 _bitfield_align_1: [],
8007 _bitfield_1: __BindgenBitfieldUnit::new(
8008 new_jsjitinfo_bitfield_1!(
8009 JSJitInfo_OpType::Method as u8,
8010 JSJitInfo_AliasSet::AliasEverything as u8,
8011 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8012 false,
8013 false,
8014 false,
8015 false,
8016 false,
8017 false,
8018 0,
8019 ).to_ne_bytes()
8020 ),
8021});
8022}
8023unsafe extern "C" fn bufferSubData<D: DomTypes>
8024(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8025 let mut result = false;
8026 wrap_panic(&mut || result = (|| {
8027 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8028 let this = &*(this as *const D::WebGL2RenderingContext);
8029 let args = &*args;
8030 let argc = args.argc_;
8031
8032 let argcount = cmp::min(argc, 5);
8033 match argcount {
8034 3 => {
8035 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8036 Ok(ConversionResult::Success(value)) => value,
8037 Ok(ConversionResult::Failure(error)) => {
8038 throw_type_error(cx.raw_cx(), &error);
8039 return false;
8040
8041 }
8042 _ => {
8043 return false;
8044
8045 },
8046 }
8047 ;
8048 let arg1: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8049 Ok(ConversionResult::Success(value)) => value,
8050 Ok(ConversionResult::Failure(error)) => {
8051 throw_type_error(cx.raw_cx(), &error);
8052 return false;
8053
8054 }
8055 _ => {
8056 return false;
8057
8058 },
8059 }
8060 ;
8061 let arg2: GenericUnionTypes::ArrayBufferViewOrArrayBuffer = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
8062 Ok(ConversionResult::Success(value)) => value,
8063 Ok(ConversionResult::Failure(error)) => {
8064 throw_type_error(cx.raw_cx(), &error);
8065 return false;
8066
8067 }
8068 _ => {
8069 return false;
8070
8071 },
8072 }
8073 ;
8074 let result: () = this.BufferSubData(arg0, arg1, arg2);
8075
8076 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8077 return true;
8078 }
8079 4 => {
8080 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8081 Ok(ConversionResult::Success(value)) => value,
8082 Ok(ConversionResult::Failure(error)) => {
8083 throw_type_error(cx.raw_cx(), &error);
8084 return false;
8085
8086 }
8087 _ => {
8088 return false;
8089
8090 },
8091 }
8092 ;
8093 let arg1: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8094 Ok(ConversionResult::Success(value)) => value,
8095 Ok(ConversionResult::Failure(error)) => {
8096 throw_type_error(cx.raw_cx(), &error);
8097 return false;
8098
8099 }
8100 _ => {
8101 return false;
8102
8103 },
8104 }
8105 ;
8106 let arg2: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(2)).get().is_object() {
8107 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(2)).get().to_object()) {
8108 Ok(val) => val,
8109 Err(()) => {
8110 throw_type_error(cx.raw_cx(), "value is not a typed array.");
8111 return false;
8112
8113 }
8114 }
8115
8116 } else {
8117 throw_type_error(cx.raw_cx(), "Value is not an object.");
8118 return false;
8119
8120 };
8121 auto_root!(&in(cx) let arg2 = arg2);
8122 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8123 Ok(ConversionResult::Success(value)) => value,
8124 Ok(ConversionResult::Failure(error)) => {
8125 throw_type_error(cx.raw_cx(), &error);
8126 return false;
8127
8128 }
8129 _ => {
8130 return false;
8131
8132 },
8133 }
8134 ;
8135 let arg4: u32 = if args.get(4).is_undefined() {
8136 0
8137 } else {
8138 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
8139 Ok(ConversionResult::Success(value)) => value,
8140 Ok(ConversionResult::Failure(error)) => {
8141 throw_type_error(cx.raw_cx(), &error);
8142 return false;
8143
8144 }
8145 _ => {
8146 return false;
8147
8148 },
8149 }
8150
8151 };
8152 let result: () = this.BufferSubData_(arg0, arg1, arg2, arg3, arg4);
8153
8154 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8155 return true;
8156 }
8157 5 => {
8158 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8159 Ok(ConversionResult::Success(value)) => value,
8160 Ok(ConversionResult::Failure(error)) => {
8161 throw_type_error(cx.raw_cx(), &error);
8162 return false;
8163
8164 }
8165 _ => {
8166 return false;
8167
8168 },
8169 }
8170 ;
8171 let arg1: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8172 Ok(ConversionResult::Success(value)) => value,
8173 Ok(ConversionResult::Failure(error)) => {
8174 throw_type_error(cx.raw_cx(), &error);
8175 return false;
8176
8177 }
8178 _ => {
8179 return false;
8180
8181 },
8182 }
8183 ;
8184 let arg2: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(2)).get().is_object() {
8185 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(2)).get().to_object()) {
8186 Ok(val) => val,
8187 Err(()) => {
8188 throw_type_error(cx.raw_cx(), "value is not a typed array.");
8189 return false;
8190
8191 }
8192 }
8193
8194 } else {
8195 throw_type_error(cx.raw_cx(), "Value is not an object.");
8196 return false;
8197
8198 };
8199 auto_root!(&in(cx) let arg2 = arg2);
8200 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8201 Ok(ConversionResult::Success(value)) => value,
8202 Ok(ConversionResult::Failure(error)) => {
8203 throw_type_error(cx.raw_cx(), &error);
8204 return false;
8205
8206 }
8207 _ => {
8208 return false;
8209
8210 },
8211 }
8212 ;
8213 let arg4: u32 = if args.get(4).is_undefined() {
8214 0
8215 } else {
8216 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
8217 Ok(ConversionResult::Success(value)) => value,
8218 Ok(ConversionResult::Failure(error)) => {
8219 throw_type_error(cx.raw_cx(), &error);
8220 return false;
8221
8222 }
8223 _ => {
8224 return false;
8225
8226 },
8227 }
8228
8229 };
8230 let result: () = this.BufferSubData_(arg0, arg1, arg2, arg3, arg4);
8231
8232 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8233 return true;
8234 }
8235 _ => {
8236 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bufferSubData\".");
8237 return false;
8238 }
8239 }
8240 })());
8241 result
8242}
8243
8244
8245static bufferSubData_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8246
8247pub(crate) fn init_bufferSubData_methodinfo<D: DomTypes>() {
8248 bufferSubData_methodinfo.set(JSJitInfo {
8249 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8250 method: Some(bufferSubData::<D>)
8251 },
8252 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8253 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
8254 },
8255 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8256 _bitfield_align_1: [],
8257 _bitfield_1: __BindgenBitfieldUnit::new(
8258 new_jsjitinfo_bitfield_1!(
8259 JSJitInfo_OpType::Method as u8,
8260 JSJitInfo_AliasSet::AliasEverything as u8,
8261 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8262 false,
8263 false,
8264 false,
8265 false,
8266 false,
8267 false,
8268 0,
8269 ).to_ne_bytes()
8270 ),
8271});
8272}
8273unsafe extern "C" fn texImage2D<D: DomTypes>
8274(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8275 let mut result = false;
8276 wrap_panic(&mut || result = (|| {
8277 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8278 let this = &*(this as *const D::WebGL2RenderingContext);
8279 let args = &*args;
8280 let argc = args.argc_;
8281
8282 let argcount = cmp::min(argc, 10);
8283 match argcount {
8284 6 => {
8285 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8286 Ok(ConversionResult::Success(value)) => value,
8287 Ok(ConversionResult::Failure(error)) => {
8288 throw_type_error(cx.raw_cx(), &error);
8289 return false;
8290
8291 }
8292 _ => {
8293 return false;
8294
8295 },
8296 }
8297 ;
8298 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8299 Ok(ConversionResult::Success(value)) => value,
8300 Ok(ConversionResult::Failure(error)) => {
8301 throw_type_error(cx.raw_cx(), &error);
8302 return false;
8303
8304 }
8305 _ => {
8306 return false;
8307
8308 },
8309 }
8310 ;
8311 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
8312 Ok(ConversionResult::Success(value)) => value,
8313 Ok(ConversionResult::Failure(error)) => {
8314 throw_type_error(cx.raw_cx(), &error);
8315 return false;
8316
8317 }
8318 _ => {
8319 return false;
8320
8321 },
8322 }
8323 ;
8324 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8325 Ok(ConversionResult::Success(value)) => value,
8326 Ok(ConversionResult::Failure(error)) => {
8327 throw_type_error(cx.raw_cx(), &error);
8328 return false;
8329
8330 }
8331 _ => {
8332 return false;
8333
8334 },
8335 }
8336 ;
8337 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
8338 Ok(ConversionResult::Success(value)) => value,
8339 Ok(ConversionResult::Failure(error)) => {
8340 throw_type_error(cx.raw_cx(), &error);
8341 return false;
8342
8343 }
8344 _ => {
8345 return false;
8346
8347 },
8348 }
8349 ;
8350 let arg5: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ()) {
8351 Ok(ConversionResult::Success(value)) => value,
8352 Ok(ConversionResult::Failure(error)) => {
8353 throw_type_error(cx.raw_cx(), &error);
8354 return false;
8355
8356 }
8357 _ => {
8358 return false;
8359
8360 },
8361 }
8362 ;
8363 let result: Result<(), Error> = this.TexImage2D_(arg0, arg1, arg2, arg3, arg4, arg5);
8364 let result = match result {
8365 Ok(result) => result,
8366 Err(e) => {
8367 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
8368 return false;
8369 },
8370 };
8371
8372 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8373 return true;
8374 }
8375 9 => {
8376 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8377 Ok(ConversionResult::Success(value)) => value,
8378 Ok(ConversionResult::Failure(error)) => {
8379 throw_type_error(cx.raw_cx(), &error);
8380 return false;
8381
8382 }
8383 _ => {
8384 return false;
8385
8386 },
8387 }
8388 ;
8389 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8390 Ok(ConversionResult::Success(value)) => value,
8391 Ok(ConversionResult::Failure(error)) => {
8392 throw_type_error(cx.raw_cx(), &error);
8393 return false;
8394
8395 }
8396 _ => {
8397 return false;
8398
8399 },
8400 }
8401 ;
8402 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
8403 Ok(ConversionResult::Success(value)) => value,
8404 Ok(ConversionResult::Failure(error)) => {
8405 throw_type_error(cx.raw_cx(), &error);
8406 return false;
8407
8408 }
8409 _ => {
8410 return false;
8411
8412 },
8413 }
8414 ;
8415 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8416 Ok(ConversionResult::Success(value)) => value,
8417 Ok(ConversionResult::Failure(error)) => {
8418 throw_type_error(cx.raw_cx(), &error);
8419 return false;
8420
8421 }
8422 _ => {
8423 return false;
8424
8425 },
8426 }
8427 ;
8428 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
8429 Ok(ConversionResult::Success(value)) => value,
8430 Ok(ConversionResult::Failure(error)) => {
8431 throw_type_error(cx.raw_cx(), &error);
8432 return false;
8433
8434 }
8435 _ => {
8436 return false;
8437
8438 },
8439 }
8440 ;
8441 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
8442 Ok(ConversionResult::Success(value)) => value,
8443 Ok(ConversionResult::Failure(error)) => {
8444 throw_type_error(cx.raw_cx(), &error);
8445 return false;
8446
8447 }
8448 _ => {
8449 return false;
8450
8451 },
8452 }
8453 ;
8454 let arg6: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
8455 Ok(ConversionResult::Success(value)) => value,
8456 Ok(ConversionResult::Failure(error)) => {
8457 throw_type_error(cx.raw_cx(), &error);
8458 return false;
8459
8460 }
8461 _ => {
8462 return false;
8463
8464 },
8465 }
8466 ;
8467 let arg7: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
8468 Ok(ConversionResult::Success(value)) => value,
8469 Ok(ConversionResult::Failure(error)) => {
8470 throw_type_error(cx.raw_cx(), &error);
8471 return false;
8472
8473 }
8474 _ => {
8475 return false;
8476
8477 },
8478 }
8479 ;
8480 if HandleValue::from_raw(args.get(8)).get().is_null_or_undefined() {
8481 let arg8: Option<typedarray::ArrayBufferView> = if HandleValue::from_raw(args.get(8)).get().is_object() {
8482 Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(8)).get().to_object()) {
8483 Ok(val) => val,
8484 Err(()) => {
8485 throw_type_error(cx.raw_cx(), "value is not a typed array.");
8486 return false;
8487
8488 }
8489 }
8490 )
8491 } else if HandleValue::from_raw(args.get(8)).get().is_null_or_undefined() {
8492 None
8493 } else {
8494 throw_type_error(cx.raw_cx(), "Value is not an object.");
8495 return false;
8496
8497 };
8498 auto_root!(&in(cx) let arg8 = arg8);
8499 let result: Result<(), Error> = this.TexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
8500 let result = match result {
8501 Ok(result) => result,
8502 Err(e) => {
8503 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
8504 return false;
8505 },
8506 };
8507
8508 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8509 return true;
8510 }
8511 if HandleValue::from_raw(args.get(8)).get().is_object() {
8512 '_block: {
8513 let arg8: Option<typedarray::ArrayBufferView> = Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(8)).get().to_object()) {
8514 Ok(val) => val,
8515 Err(()) => {
8516 break '_block;
8517 }
8518 }
8519 );
8520 auto_root!(&in(cx) let arg8 = arg8);
8521 let result: Result<(), Error> = this.TexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
8522 let result = match result {
8523 Ok(result) => result,
8524 Err(e) => {
8525 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
8526 return false;
8527 },
8528 };
8529
8530 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8531 return true;
8532 }
8533 '_block: {
8534 let arg8: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(8)), ()) {
8535 Ok(ConversionResult::Success(value)) => value,
8536 Ok(ConversionResult::Failure(error)) => {
8537 break '_block;
8538 }
8539 _ => {
8540 return false;
8541
8542 },
8543 }
8544 ;
8545 let result: Result<(), Error> = this.TexImage2D___(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
8546 let result = match result {
8547 Ok(result) => result,
8548 Err(e) => {
8549 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
8550 return false;
8551 },
8552 };
8553
8554 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8555 return true;
8556 }
8557 }
8558 let arg8: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(8)), ConversionBehavior::Default) {
8559 Ok(ConversionResult::Success(value)) => value,
8560 Ok(ConversionResult::Failure(error)) => {
8561 throw_type_error(cx.raw_cx(), &error);
8562 return false;
8563
8564 }
8565 _ => {
8566 return false;
8567
8568 },
8569 }
8570 ;
8571 let result: Result<(), Error> = this.TexImage2D__(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
8572 let result = match result {
8573 Ok(result) => result,
8574 Err(e) => {
8575 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
8576 return false;
8577 },
8578 };
8579
8580 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8581 return true;
8582 }
8583 10 => {
8584 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8585 Ok(ConversionResult::Success(value)) => value,
8586 Ok(ConversionResult::Failure(error)) => {
8587 throw_type_error(cx.raw_cx(), &error);
8588 return false;
8589
8590 }
8591 _ => {
8592 return false;
8593
8594 },
8595 }
8596 ;
8597 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8598 Ok(ConversionResult::Success(value)) => value,
8599 Ok(ConversionResult::Failure(error)) => {
8600 throw_type_error(cx.raw_cx(), &error);
8601 return false;
8602
8603 }
8604 _ => {
8605 return false;
8606
8607 },
8608 }
8609 ;
8610 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
8611 Ok(ConversionResult::Success(value)) => value,
8612 Ok(ConversionResult::Failure(error)) => {
8613 throw_type_error(cx.raw_cx(), &error);
8614 return false;
8615
8616 }
8617 _ => {
8618 return false;
8619
8620 },
8621 }
8622 ;
8623 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8624 Ok(ConversionResult::Success(value)) => value,
8625 Ok(ConversionResult::Failure(error)) => {
8626 throw_type_error(cx.raw_cx(), &error);
8627 return false;
8628
8629 }
8630 _ => {
8631 return false;
8632
8633 },
8634 }
8635 ;
8636 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
8637 Ok(ConversionResult::Success(value)) => value,
8638 Ok(ConversionResult::Failure(error)) => {
8639 throw_type_error(cx.raw_cx(), &error);
8640 return false;
8641
8642 }
8643 _ => {
8644 return false;
8645
8646 },
8647 }
8648 ;
8649 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
8650 Ok(ConversionResult::Success(value)) => value,
8651 Ok(ConversionResult::Failure(error)) => {
8652 throw_type_error(cx.raw_cx(), &error);
8653 return false;
8654
8655 }
8656 _ => {
8657 return false;
8658
8659 },
8660 }
8661 ;
8662 let arg6: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
8663 Ok(ConversionResult::Success(value)) => value,
8664 Ok(ConversionResult::Failure(error)) => {
8665 throw_type_error(cx.raw_cx(), &error);
8666 return false;
8667
8668 }
8669 _ => {
8670 return false;
8671
8672 },
8673 }
8674 ;
8675 let arg7: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
8676 Ok(ConversionResult::Success(value)) => value,
8677 Ok(ConversionResult::Failure(error)) => {
8678 throw_type_error(cx.raw_cx(), &error);
8679 return false;
8680
8681 }
8682 _ => {
8683 return false;
8684
8685 },
8686 }
8687 ;
8688 let arg8: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(8)).get().is_object() {
8689 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(8)).get().to_object()) {
8690 Ok(val) => val,
8691 Err(()) => {
8692 throw_type_error(cx.raw_cx(), "value is not a typed array.");
8693 return false;
8694
8695 }
8696 }
8697
8698 } else {
8699 throw_type_error(cx.raw_cx(), "Value is not an object.");
8700 return false;
8701
8702 };
8703 auto_root!(&in(cx) let arg8 = arg8);
8704 let arg9: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(9)), ConversionBehavior::Default) {
8705 Ok(ConversionResult::Success(value)) => value,
8706 Ok(ConversionResult::Failure(error)) => {
8707 throw_type_error(cx.raw_cx(), &error);
8708 return false;
8709
8710 }
8711 _ => {
8712 return false;
8713
8714 },
8715 }
8716 ;
8717 let result: Result<(), Error> = this.TexImage2D____(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
8718 let result = match result {
8719 Ok(result) => result,
8720 Err(e) => {
8721 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
8722 return false;
8723 },
8724 };
8725
8726 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8727 return true;
8728 }
8729 _ => {
8730 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.texImage2D\".");
8731 return false;
8732 }
8733 }
8734 })());
8735 result
8736}
8737
8738
8739static texImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8740
8741pub(crate) fn init_texImage2D_methodinfo<D: DomTypes>() {
8742 texImage2D_methodinfo.set(JSJitInfo {
8743 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8744 method: Some(texImage2D::<D>)
8745 },
8746 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8747 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
8748 },
8749 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8750 _bitfield_align_1: [],
8751 _bitfield_1: __BindgenBitfieldUnit::new(
8752 new_jsjitinfo_bitfield_1!(
8753 JSJitInfo_OpType::Method as u8,
8754 JSJitInfo_AliasSet::AliasEverything as u8,
8755 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8756 false,
8757 false,
8758 false,
8759 false,
8760 false,
8761 false,
8762 0,
8763 ).to_ne_bytes()
8764 ),
8765});
8766}
8767unsafe extern "C" fn texSubImage2D<D: DomTypes>
8768(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8769 let mut result = false;
8770 wrap_panic(&mut || result = (|| {
8771 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8772 let this = &*(this as *const D::WebGL2RenderingContext);
8773 let args = &*args;
8774 let argc = args.argc_;
8775
8776 let argcount = cmp::min(argc, 9);
8777 match argcount {
8778 7 => {
8779 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8780 Ok(ConversionResult::Success(value)) => value,
8781 Ok(ConversionResult::Failure(error)) => {
8782 throw_type_error(cx.raw_cx(), &error);
8783 return false;
8784
8785 }
8786 _ => {
8787 return false;
8788
8789 },
8790 }
8791 ;
8792 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8793 Ok(ConversionResult::Success(value)) => value,
8794 Ok(ConversionResult::Failure(error)) => {
8795 throw_type_error(cx.raw_cx(), &error);
8796 return false;
8797
8798 }
8799 _ => {
8800 return false;
8801
8802 },
8803 }
8804 ;
8805 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
8806 Ok(ConversionResult::Success(value)) => value,
8807 Ok(ConversionResult::Failure(error)) => {
8808 throw_type_error(cx.raw_cx(), &error);
8809 return false;
8810
8811 }
8812 _ => {
8813 return false;
8814
8815 },
8816 }
8817 ;
8818 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8819 Ok(ConversionResult::Success(value)) => value,
8820 Ok(ConversionResult::Failure(error)) => {
8821 throw_type_error(cx.raw_cx(), &error);
8822 return false;
8823
8824 }
8825 _ => {
8826 return false;
8827
8828 },
8829 }
8830 ;
8831 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
8832 Ok(ConversionResult::Success(value)) => value,
8833 Ok(ConversionResult::Failure(error)) => {
8834 throw_type_error(cx.raw_cx(), &error);
8835 return false;
8836
8837 }
8838 _ => {
8839 return false;
8840
8841 },
8842 }
8843 ;
8844 let arg5: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
8845 Ok(ConversionResult::Success(value)) => value,
8846 Ok(ConversionResult::Failure(error)) => {
8847 throw_type_error(cx.raw_cx(), &error);
8848 return false;
8849
8850 }
8851 _ => {
8852 return false;
8853
8854 },
8855 }
8856 ;
8857 let arg6: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ()) {
8858 Ok(ConversionResult::Success(value)) => value,
8859 Ok(ConversionResult::Failure(error)) => {
8860 throw_type_error(cx.raw_cx(), &error);
8861 return false;
8862
8863 }
8864 _ => {
8865 return false;
8866
8867 },
8868 }
8869 ;
8870 let result: Result<(), Error> = this.TexSubImage2D_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
8871 let result = match result {
8872 Ok(result) => result,
8873 Err(e) => {
8874 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
8875 return false;
8876 },
8877 };
8878
8879 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8880 return true;
8881 }
8882 9 => {
8883 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8884 Ok(ConversionResult::Success(value)) => value,
8885 Ok(ConversionResult::Failure(error)) => {
8886 throw_type_error(cx.raw_cx(), &error);
8887 return false;
8888
8889 }
8890 _ => {
8891 return false;
8892
8893 },
8894 }
8895 ;
8896 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8897 Ok(ConversionResult::Success(value)) => value,
8898 Ok(ConversionResult::Failure(error)) => {
8899 throw_type_error(cx.raw_cx(), &error);
8900 return false;
8901
8902 }
8903 _ => {
8904 return false;
8905
8906 },
8907 }
8908 ;
8909 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
8910 Ok(ConversionResult::Success(value)) => value,
8911 Ok(ConversionResult::Failure(error)) => {
8912 throw_type_error(cx.raw_cx(), &error);
8913 return false;
8914
8915 }
8916 _ => {
8917 return false;
8918
8919 },
8920 }
8921 ;
8922 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8923 Ok(ConversionResult::Success(value)) => value,
8924 Ok(ConversionResult::Failure(error)) => {
8925 throw_type_error(cx.raw_cx(), &error);
8926 return false;
8927
8928 }
8929 _ => {
8930 return false;
8931
8932 },
8933 }
8934 ;
8935 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
8936 Ok(ConversionResult::Success(value)) => value,
8937 Ok(ConversionResult::Failure(error)) => {
8938 throw_type_error(cx.raw_cx(), &error);
8939 return false;
8940
8941 }
8942 _ => {
8943 return false;
8944
8945 },
8946 }
8947 ;
8948 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
8949 Ok(ConversionResult::Success(value)) => value,
8950 Ok(ConversionResult::Failure(error)) => {
8951 throw_type_error(cx.raw_cx(), &error);
8952 return false;
8953
8954 }
8955 _ => {
8956 return false;
8957
8958 },
8959 }
8960 ;
8961 let arg6: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
8962 Ok(ConversionResult::Success(value)) => value,
8963 Ok(ConversionResult::Failure(error)) => {
8964 throw_type_error(cx.raw_cx(), &error);
8965 return false;
8966
8967 }
8968 _ => {
8969 return false;
8970
8971 },
8972 }
8973 ;
8974 let arg7: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
8975 Ok(ConversionResult::Success(value)) => value,
8976 Ok(ConversionResult::Failure(error)) => {
8977 throw_type_error(cx.raw_cx(), &error);
8978 return false;
8979
8980 }
8981 _ => {
8982 return false;
8983
8984 },
8985 }
8986 ;
8987 let arg8: Option<typedarray::ArrayBufferView> = if HandleValue::from_raw(args.get(8)).get().is_object() {
8988 Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(8)).get().to_object()) {
8989 Ok(val) => val,
8990 Err(()) => {
8991 throw_type_error(cx.raw_cx(), "value is not a typed array.");
8992 return false;
8993
8994 }
8995 }
8996 )
8997 } else if HandleValue::from_raw(args.get(8)).get().is_null_or_undefined() {
8998 None
8999 } else {
9000 throw_type_error(cx.raw_cx(), "Value is not an object.");
9001 return false;
9002
9003 };
9004 auto_root!(&in(cx) let arg8 = arg8);
9005 let result: Result<(), Error> = this.TexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
9006 let result = match result {
9007 Ok(result) => result,
9008 Err(e) => {
9009 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
9010 return false;
9011 },
9012 };
9013
9014 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9015 return true;
9016 }
9017 _ => {
9018 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.texSubImage2D\".");
9019 return false;
9020 }
9021 }
9022 })());
9023 result
9024}
9025
9026
9027static texSubImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9028
9029pub(crate) fn init_texSubImage2D_methodinfo<D: DomTypes>() {
9030 texSubImage2D_methodinfo.set(JSJitInfo {
9031 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9032 method: Some(texSubImage2D::<D>)
9033 },
9034 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9035 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
9036 },
9037 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9038 _bitfield_align_1: [],
9039 _bitfield_1: __BindgenBitfieldUnit::new(
9040 new_jsjitinfo_bitfield_1!(
9041 JSJitInfo_OpType::Method as u8,
9042 JSJitInfo_AliasSet::AliasEverything as u8,
9043 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9044 false,
9045 false,
9046 false,
9047 false,
9048 false,
9049 false,
9050 0,
9051 ).to_ne_bytes()
9052 ),
9053});
9054}
9055unsafe extern "C" fn compressedTexImage2D<D: DomTypes>
9056(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9057 let mut result = false;
9058 wrap_panic(&mut || result = (|| {
9059 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9060 let this = &*(this as *const D::WebGL2RenderingContext);
9061 let args = &*args;
9062 let argc = args.argc_;
9063
9064 if argc < 7 {
9065 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.compressedTexImage2D\".");
9066 return false;
9067 }
9068 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9069 Ok(ConversionResult::Success(value)) => value,
9070 Ok(ConversionResult::Failure(error)) => {
9071 throw_type_error(cx.raw_cx(), &error);
9072 return false;
9073
9074 }
9075 _ => {
9076 return false;
9077
9078 },
9079 }
9080 ;
9081 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
9082 Ok(ConversionResult::Success(value)) => value,
9083 Ok(ConversionResult::Failure(error)) => {
9084 throw_type_error(cx.raw_cx(), &error);
9085 return false;
9086
9087 }
9088 _ => {
9089 return false;
9090
9091 },
9092 }
9093 ;
9094 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9095 Ok(ConversionResult::Success(value)) => value,
9096 Ok(ConversionResult::Failure(error)) => {
9097 throw_type_error(cx.raw_cx(), &error);
9098 return false;
9099
9100 }
9101 _ => {
9102 return false;
9103
9104 },
9105 }
9106 ;
9107 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9108 Ok(ConversionResult::Success(value)) => value,
9109 Ok(ConversionResult::Failure(error)) => {
9110 throw_type_error(cx.raw_cx(), &error);
9111 return false;
9112
9113 }
9114 _ => {
9115 return false;
9116
9117 },
9118 }
9119 ;
9120 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
9121 Ok(ConversionResult::Success(value)) => value,
9122 Ok(ConversionResult::Failure(error)) => {
9123 throw_type_error(cx.raw_cx(), &error);
9124 return false;
9125
9126 }
9127 _ => {
9128 return false;
9129
9130 },
9131 }
9132 ;
9133 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
9134 Ok(ConversionResult::Success(value)) => value,
9135 Ok(ConversionResult::Failure(error)) => {
9136 throw_type_error(cx.raw_cx(), &error);
9137 return false;
9138
9139 }
9140 _ => {
9141 return false;
9142
9143 },
9144 }
9145 ;
9146 let arg6: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(6)).get().is_object() {
9147 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(6)).get().to_object()) {
9148 Ok(val) => val,
9149 Err(()) => {
9150 throw_type_error(cx.raw_cx(), "value is not a typed array.");
9151 return false;
9152
9153 }
9154 }
9155
9156 } else {
9157 throw_type_error(cx.raw_cx(), "Value is not an object.");
9158 return false;
9159
9160 };
9161 auto_root!(&in(cx) let arg6 = arg6);
9162 let arg7: u32 = if args.get(7).is_undefined() {
9163 0
9164 } else {
9165 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
9166 Ok(ConversionResult::Success(value)) => value,
9167 Ok(ConversionResult::Failure(error)) => {
9168 throw_type_error(cx.raw_cx(), &error);
9169 return false;
9170
9171 }
9172 _ => {
9173 return false;
9174
9175 },
9176 }
9177
9178 };
9179 let arg8: u32 = if args.get(8).is_undefined() {
9180 0
9181 } else {
9182 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(8)), ConversionBehavior::Default) {
9183 Ok(ConversionResult::Success(value)) => value,
9184 Ok(ConversionResult::Failure(error)) => {
9185 throw_type_error(cx.raw_cx(), &error);
9186 return false;
9187
9188 }
9189 _ => {
9190 return false;
9191
9192 },
9193 }
9194
9195 };
9196 let result: () = this.CompressedTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
9197
9198 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9199 return true;
9200 })());
9201 result
9202}
9203
9204
9205static compressedTexImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9206
9207pub(crate) fn init_compressedTexImage2D_methodinfo<D: DomTypes>() {
9208 compressedTexImage2D_methodinfo.set(JSJitInfo {
9209 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9210 method: Some(compressedTexImage2D::<D>)
9211 },
9212 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9213 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
9214 },
9215 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9216 _bitfield_align_1: [],
9217 _bitfield_1: __BindgenBitfieldUnit::new(
9218 new_jsjitinfo_bitfield_1!(
9219 JSJitInfo_OpType::Method as u8,
9220 JSJitInfo_AliasSet::AliasEverything as u8,
9221 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9222 false,
9223 false,
9224 false,
9225 false,
9226 false,
9227 false,
9228 0,
9229 ).to_ne_bytes()
9230 ),
9231});
9232}
9233unsafe extern "C" fn compressedTexSubImage2D<D: DomTypes>
9234(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9235 let mut result = false;
9236 wrap_panic(&mut || result = (|| {
9237 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9238 let this = &*(this as *const D::WebGL2RenderingContext);
9239 let args = &*args;
9240 let argc = args.argc_;
9241
9242 if argc < 8 {
9243 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.compressedTexSubImage2D\".");
9244 return false;
9245 }
9246 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9247 Ok(ConversionResult::Success(value)) => value,
9248 Ok(ConversionResult::Failure(error)) => {
9249 throw_type_error(cx.raw_cx(), &error);
9250 return false;
9251
9252 }
9253 _ => {
9254 return false;
9255
9256 },
9257 }
9258 ;
9259 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
9260 Ok(ConversionResult::Success(value)) => value,
9261 Ok(ConversionResult::Failure(error)) => {
9262 throw_type_error(cx.raw_cx(), &error);
9263 return false;
9264
9265 }
9266 _ => {
9267 return false;
9268
9269 },
9270 }
9271 ;
9272 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9273 Ok(ConversionResult::Success(value)) => value,
9274 Ok(ConversionResult::Failure(error)) => {
9275 throw_type_error(cx.raw_cx(), &error);
9276 return false;
9277
9278 }
9279 _ => {
9280 return false;
9281
9282 },
9283 }
9284 ;
9285 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9286 Ok(ConversionResult::Success(value)) => value,
9287 Ok(ConversionResult::Failure(error)) => {
9288 throw_type_error(cx.raw_cx(), &error);
9289 return false;
9290
9291 }
9292 _ => {
9293 return false;
9294
9295 },
9296 }
9297 ;
9298 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
9299 Ok(ConversionResult::Success(value)) => value,
9300 Ok(ConversionResult::Failure(error)) => {
9301 throw_type_error(cx.raw_cx(), &error);
9302 return false;
9303
9304 }
9305 _ => {
9306 return false;
9307
9308 },
9309 }
9310 ;
9311 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
9312 Ok(ConversionResult::Success(value)) => value,
9313 Ok(ConversionResult::Failure(error)) => {
9314 throw_type_error(cx.raw_cx(), &error);
9315 return false;
9316
9317 }
9318 _ => {
9319 return false;
9320
9321 },
9322 }
9323 ;
9324 let arg6: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
9325 Ok(ConversionResult::Success(value)) => value,
9326 Ok(ConversionResult::Failure(error)) => {
9327 throw_type_error(cx.raw_cx(), &error);
9328 return false;
9329
9330 }
9331 _ => {
9332 return false;
9333
9334 },
9335 }
9336 ;
9337 let arg7: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(7)).get().is_object() {
9338 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(7)).get().to_object()) {
9339 Ok(val) => val,
9340 Err(()) => {
9341 throw_type_error(cx.raw_cx(), "value is not a typed array.");
9342 return false;
9343
9344 }
9345 }
9346
9347 } else {
9348 throw_type_error(cx.raw_cx(), "Value is not an object.");
9349 return false;
9350
9351 };
9352 auto_root!(&in(cx) let arg7 = arg7);
9353 let arg8: u32 = if args.get(8).is_undefined() {
9354 0
9355 } else {
9356 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(8)), ConversionBehavior::Default) {
9357 Ok(ConversionResult::Success(value)) => value,
9358 Ok(ConversionResult::Failure(error)) => {
9359 throw_type_error(cx.raw_cx(), &error);
9360 return false;
9361
9362 }
9363 _ => {
9364 return false;
9365
9366 },
9367 }
9368
9369 };
9370 let arg9: u32 = if args.get(9).is_undefined() {
9371 0
9372 } else {
9373 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(9)), ConversionBehavior::Default) {
9374 Ok(ConversionResult::Success(value)) => value,
9375 Ok(ConversionResult::Failure(error)) => {
9376 throw_type_error(cx.raw_cx(), &error);
9377 return false;
9378
9379 }
9380 _ => {
9381 return false;
9382
9383 },
9384 }
9385
9386 };
9387 let result: () = this.CompressedTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
9388
9389 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9390 return true;
9391 })());
9392 result
9393}
9394
9395
9396static compressedTexSubImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9397
9398pub(crate) fn init_compressedTexSubImage2D_methodinfo<D: DomTypes>() {
9399 compressedTexSubImage2D_methodinfo.set(JSJitInfo {
9400 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9401 method: Some(compressedTexSubImage2D::<D>)
9402 },
9403 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9404 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
9405 },
9406 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9407 _bitfield_align_1: [],
9408 _bitfield_1: __BindgenBitfieldUnit::new(
9409 new_jsjitinfo_bitfield_1!(
9410 JSJitInfo_OpType::Method as u8,
9411 JSJitInfo_AliasSet::AliasEverything as u8,
9412 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9413 false,
9414 false,
9415 false,
9416 false,
9417 false,
9418 false,
9419 0,
9420 ).to_ne_bytes()
9421 ),
9422});
9423}
9424unsafe extern "C" fn uniform1fv<D: DomTypes>
9425(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9426 let mut result = false;
9427 wrap_panic(&mut || result = (|| {
9428 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9429 let this = &*(this as *const D::WebGL2RenderingContext);
9430 let args = &*args;
9431 let argc = args.argc_;
9432
9433 if argc < 2 {
9434 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform1fv\".");
9435 return false;
9436 }
9437 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9438 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
9439 Ok(val) => val,
9440 Err(()) => {
9441 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
9442 return false;
9443
9444 }
9445 }
9446 )
9447 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
9448 None
9449 } else {
9450 throw_type_error(cx.raw_cx(), "Value is not an object.");
9451 return false;
9452
9453 };
9454 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9455 Ok(ConversionResult::Success(value)) => value,
9456 Ok(ConversionResult::Failure(error)) => {
9457 throw_type_error(cx.raw_cx(), &error);
9458 return false;
9459
9460 }
9461 _ => {
9462 return false;
9463
9464 },
9465 }
9466 ;
9467 let arg2: u32 = if args.get(2).is_undefined() {
9468 0
9469 } else {
9470 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9471 Ok(ConversionResult::Success(value)) => value,
9472 Ok(ConversionResult::Failure(error)) => {
9473 throw_type_error(cx.raw_cx(), &error);
9474 return false;
9475
9476 }
9477 _ => {
9478 return false;
9479
9480 },
9481 }
9482
9483 };
9484 let arg3: u32 = if args.get(3).is_undefined() {
9485 0
9486 } else {
9487 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9488 Ok(ConversionResult::Success(value)) => value,
9489 Ok(ConversionResult::Failure(error)) => {
9490 throw_type_error(cx.raw_cx(), &error);
9491 return false;
9492
9493 }
9494 _ => {
9495 return false;
9496
9497 },
9498 }
9499
9500 };
9501 let result: () = this.Uniform1fv(arg0.as_deref(), arg1, arg2, arg3);
9502
9503 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9504 return true;
9505 })());
9506 result
9507}
9508
9509
9510static uniform1fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9511
9512pub(crate) fn init_uniform1fv_methodinfo<D: DomTypes>() {
9513 uniform1fv_methodinfo.set(JSJitInfo {
9514 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9515 method: Some(uniform1fv::<D>)
9516 },
9517 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9518 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
9519 },
9520 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9521 _bitfield_align_1: [],
9522 _bitfield_1: __BindgenBitfieldUnit::new(
9523 new_jsjitinfo_bitfield_1!(
9524 JSJitInfo_OpType::Method as u8,
9525 JSJitInfo_AliasSet::AliasEverything as u8,
9526 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9527 false,
9528 false,
9529 false,
9530 false,
9531 false,
9532 false,
9533 0,
9534 ).to_ne_bytes()
9535 ),
9536});
9537}
9538unsafe extern "C" fn uniform2fv<D: DomTypes>
9539(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9540 let mut result = false;
9541 wrap_panic(&mut || result = (|| {
9542 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9543 let this = &*(this as *const D::WebGL2RenderingContext);
9544 let args = &*args;
9545 let argc = args.argc_;
9546
9547 if argc < 2 {
9548 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform2fv\".");
9549 return false;
9550 }
9551 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9552 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
9553 Ok(val) => val,
9554 Err(()) => {
9555 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
9556 return false;
9557
9558 }
9559 }
9560 )
9561 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
9562 None
9563 } else {
9564 throw_type_error(cx.raw_cx(), "Value is not an object.");
9565 return false;
9566
9567 };
9568 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9569 Ok(ConversionResult::Success(value)) => value,
9570 Ok(ConversionResult::Failure(error)) => {
9571 throw_type_error(cx.raw_cx(), &error);
9572 return false;
9573
9574 }
9575 _ => {
9576 return false;
9577
9578 },
9579 }
9580 ;
9581 let arg2: u32 = if args.get(2).is_undefined() {
9582 0
9583 } else {
9584 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9585 Ok(ConversionResult::Success(value)) => value,
9586 Ok(ConversionResult::Failure(error)) => {
9587 throw_type_error(cx.raw_cx(), &error);
9588 return false;
9589
9590 }
9591 _ => {
9592 return false;
9593
9594 },
9595 }
9596
9597 };
9598 let arg3: u32 = if args.get(3).is_undefined() {
9599 0
9600 } else {
9601 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9602 Ok(ConversionResult::Success(value)) => value,
9603 Ok(ConversionResult::Failure(error)) => {
9604 throw_type_error(cx.raw_cx(), &error);
9605 return false;
9606
9607 }
9608 _ => {
9609 return false;
9610
9611 },
9612 }
9613
9614 };
9615 let result: () = this.Uniform2fv(arg0.as_deref(), arg1, arg2, arg3);
9616
9617 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9618 return true;
9619 })());
9620 result
9621}
9622
9623
9624static uniform2fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9625
9626pub(crate) fn init_uniform2fv_methodinfo<D: DomTypes>() {
9627 uniform2fv_methodinfo.set(JSJitInfo {
9628 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9629 method: Some(uniform2fv::<D>)
9630 },
9631 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9632 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
9633 },
9634 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9635 _bitfield_align_1: [],
9636 _bitfield_1: __BindgenBitfieldUnit::new(
9637 new_jsjitinfo_bitfield_1!(
9638 JSJitInfo_OpType::Method as u8,
9639 JSJitInfo_AliasSet::AliasEverything as u8,
9640 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9641 false,
9642 false,
9643 false,
9644 false,
9645 false,
9646 false,
9647 0,
9648 ).to_ne_bytes()
9649 ),
9650});
9651}
9652unsafe extern "C" fn uniform3fv<D: DomTypes>
9653(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9654 let mut result = false;
9655 wrap_panic(&mut || result = (|| {
9656 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9657 let this = &*(this as *const D::WebGL2RenderingContext);
9658 let args = &*args;
9659 let argc = args.argc_;
9660
9661 if argc < 2 {
9662 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform3fv\".");
9663 return false;
9664 }
9665 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9666 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
9667 Ok(val) => val,
9668 Err(()) => {
9669 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
9670 return false;
9671
9672 }
9673 }
9674 )
9675 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
9676 None
9677 } else {
9678 throw_type_error(cx.raw_cx(), "Value is not an object.");
9679 return false;
9680
9681 };
9682 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9683 Ok(ConversionResult::Success(value)) => value,
9684 Ok(ConversionResult::Failure(error)) => {
9685 throw_type_error(cx.raw_cx(), &error);
9686 return false;
9687
9688 }
9689 _ => {
9690 return false;
9691
9692 },
9693 }
9694 ;
9695 let arg2: u32 = if args.get(2).is_undefined() {
9696 0
9697 } else {
9698 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9699 Ok(ConversionResult::Success(value)) => value,
9700 Ok(ConversionResult::Failure(error)) => {
9701 throw_type_error(cx.raw_cx(), &error);
9702 return false;
9703
9704 }
9705 _ => {
9706 return false;
9707
9708 },
9709 }
9710
9711 };
9712 let arg3: u32 = if args.get(3).is_undefined() {
9713 0
9714 } else {
9715 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9716 Ok(ConversionResult::Success(value)) => value,
9717 Ok(ConversionResult::Failure(error)) => {
9718 throw_type_error(cx.raw_cx(), &error);
9719 return false;
9720
9721 }
9722 _ => {
9723 return false;
9724
9725 },
9726 }
9727
9728 };
9729 let result: () = this.Uniform3fv(arg0.as_deref(), arg1, arg2, arg3);
9730
9731 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9732 return true;
9733 })());
9734 result
9735}
9736
9737
9738static uniform3fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9739
9740pub(crate) fn init_uniform3fv_methodinfo<D: DomTypes>() {
9741 uniform3fv_methodinfo.set(JSJitInfo {
9742 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9743 method: Some(uniform3fv::<D>)
9744 },
9745 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9746 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
9747 },
9748 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9749 _bitfield_align_1: [],
9750 _bitfield_1: __BindgenBitfieldUnit::new(
9751 new_jsjitinfo_bitfield_1!(
9752 JSJitInfo_OpType::Method as u8,
9753 JSJitInfo_AliasSet::AliasEverything as u8,
9754 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9755 false,
9756 false,
9757 false,
9758 false,
9759 false,
9760 false,
9761 0,
9762 ).to_ne_bytes()
9763 ),
9764});
9765}
9766unsafe extern "C" fn uniform4fv<D: DomTypes>
9767(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9768 let mut result = false;
9769 wrap_panic(&mut || result = (|| {
9770 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9771 let this = &*(this as *const D::WebGL2RenderingContext);
9772 let args = &*args;
9773 let argc = args.argc_;
9774
9775 if argc < 2 {
9776 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform4fv\".");
9777 return false;
9778 }
9779 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9780 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
9781 Ok(val) => val,
9782 Err(()) => {
9783 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
9784 return false;
9785
9786 }
9787 }
9788 )
9789 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
9790 None
9791 } else {
9792 throw_type_error(cx.raw_cx(), "Value is not an object.");
9793 return false;
9794
9795 };
9796 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9797 Ok(ConversionResult::Success(value)) => value,
9798 Ok(ConversionResult::Failure(error)) => {
9799 throw_type_error(cx.raw_cx(), &error);
9800 return false;
9801
9802 }
9803 _ => {
9804 return false;
9805
9806 },
9807 }
9808 ;
9809 let arg2: u32 = if args.get(2).is_undefined() {
9810 0
9811 } else {
9812 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9813 Ok(ConversionResult::Success(value)) => value,
9814 Ok(ConversionResult::Failure(error)) => {
9815 throw_type_error(cx.raw_cx(), &error);
9816 return false;
9817
9818 }
9819 _ => {
9820 return false;
9821
9822 },
9823 }
9824
9825 };
9826 let arg3: u32 = if args.get(3).is_undefined() {
9827 0
9828 } else {
9829 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9830 Ok(ConversionResult::Success(value)) => value,
9831 Ok(ConversionResult::Failure(error)) => {
9832 throw_type_error(cx.raw_cx(), &error);
9833 return false;
9834
9835 }
9836 _ => {
9837 return false;
9838
9839 },
9840 }
9841
9842 };
9843 let result: () = this.Uniform4fv(arg0.as_deref(), arg1, arg2, arg3);
9844
9845 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9846 return true;
9847 })());
9848 result
9849}
9850
9851
9852static uniform4fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9853
9854pub(crate) fn init_uniform4fv_methodinfo<D: DomTypes>() {
9855 uniform4fv_methodinfo.set(JSJitInfo {
9856 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9857 method: Some(uniform4fv::<D>)
9858 },
9859 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9860 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
9861 },
9862 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9863 _bitfield_align_1: [],
9864 _bitfield_1: __BindgenBitfieldUnit::new(
9865 new_jsjitinfo_bitfield_1!(
9866 JSJitInfo_OpType::Method as u8,
9867 JSJitInfo_AliasSet::AliasEverything as u8,
9868 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9869 false,
9870 false,
9871 false,
9872 false,
9873 false,
9874 false,
9875 0,
9876 ).to_ne_bytes()
9877 ),
9878});
9879}
9880unsafe extern "C" fn uniform1iv<D: DomTypes>
9881(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9882 let mut result = false;
9883 wrap_panic(&mut || result = (|| {
9884 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9885 let this = &*(this as *const D::WebGL2RenderingContext);
9886 let args = &*args;
9887 let argc = args.argc_;
9888
9889 if argc < 2 {
9890 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform1iv\".");
9891 return false;
9892 }
9893 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
9894 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
9895 Ok(val) => val,
9896 Err(()) => {
9897 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
9898 return false;
9899
9900 }
9901 }
9902 )
9903 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
9904 None
9905 } else {
9906 throw_type_error(cx.raw_cx(), "Value is not an object.");
9907 return false;
9908
9909 };
9910 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9911 Ok(ConversionResult::Success(value)) => value,
9912 Ok(ConversionResult::Failure(error)) => {
9913 throw_type_error(cx.raw_cx(), &error);
9914 return false;
9915
9916 }
9917 _ => {
9918 return false;
9919
9920 },
9921 }
9922 ;
9923 let arg2: u32 = if args.get(2).is_undefined() {
9924 0
9925 } else {
9926 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9927 Ok(ConversionResult::Success(value)) => value,
9928 Ok(ConversionResult::Failure(error)) => {
9929 throw_type_error(cx.raw_cx(), &error);
9930 return false;
9931
9932 }
9933 _ => {
9934 return false;
9935
9936 },
9937 }
9938
9939 };
9940 let arg3: u32 = if args.get(3).is_undefined() {
9941 0
9942 } else {
9943 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9944 Ok(ConversionResult::Success(value)) => value,
9945 Ok(ConversionResult::Failure(error)) => {
9946 throw_type_error(cx.raw_cx(), &error);
9947 return false;
9948
9949 }
9950 _ => {
9951 return false;
9952
9953 },
9954 }
9955
9956 };
9957 let result: () = this.Uniform1iv(arg0.as_deref(), arg1, arg2, arg3);
9958
9959 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9960 return true;
9961 })());
9962 result
9963}
9964
9965
9966static uniform1iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9967
9968pub(crate) fn init_uniform1iv_methodinfo<D: DomTypes>() {
9969 uniform1iv_methodinfo.set(JSJitInfo {
9970 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9971 method: Some(uniform1iv::<D>)
9972 },
9973 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9974 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
9975 },
9976 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9977 _bitfield_align_1: [],
9978 _bitfield_1: __BindgenBitfieldUnit::new(
9979 new_jsjitinfo_bitfield_1!(
9980 JSJitInfo_OpType::Method as u8,
9981 JSJitInfo_AliasSet::AliasEverything as u8,
9982 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9983 false,
9984 false,
9985 false,
9986 false,
9987 false,
9988 false,
9989 0,
9990 ).to_ne_bytes()
9991 ),
9992});
9993}
9994unsafe extern "C" fn uniform2iv<D: DomTypes>
9995(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9996 let mut result = false;
9997 wrap_panic(&mut || result = (|| {
9998 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9999 let this = &*(this as *const D::WebGL2RenderingContext);
10000 let args = &*args;
10001 let argc = args.argc_;
10002
10003 if argc < 2 {
10004 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform2iv\".");
10005 return false;
10006 }
10007 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10008 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
10009 Ok(val) => val,
10010 Err(()) => {
10011 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
10012 return false;
10013
10014 }
10015 }
10016 )
10017 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
10018 None
10019 } else {
10020 throw_type_error(cx.raw_cx(), "Value is not an object.");
10021 return false;
10022
10023 };
10024 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
10025 Ok(ConversionResult::Success(value)) => value,
10026 Ok(ConversionResult::Failure(error)) => {
10027 throw_type_error(cx.raw_cx(), &error);
10028 return false;
10029
10030 }
10031 _ => {
10032 return false;
10033
10034 },
10035 }
10036 ;
10037 let arg2: u32 = if args.get(2).is_undefined() {
10038 0
10039 } else {
10040 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10041 Ok(ConversionResult::Success(value)) => value,
10042 Ok(ConversionResult::Failure(error)) => {
10043 throw_type_error(cx.raw_cx(), &error);
10044 return false;
10045
10046 }
10047 _ => {
10048 return false;
10049
10050 },
10051 }
10052
10053 };
10054 let arg3: u32 = if args.get(3).is_undefined() {
10055 0
10056 } else {
10057 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10058 Ok(ConversionResult::Success(value)) => value,
10059 Ok(ConversionResult::Failure(error)) => {
10060 throw_type_error(cx.raw_cx(), &error);
10061 return false;
10062
10063 }
10064 _ => {
10065 return false;
10066
10067 },
10068 }
10069
10070 };
10071 let result: () = this.Uniform2iv(arg0.as_deref(), arg1, arg2, arg3);
10072
10073 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10074 return true;
10075 })());
10076 result
10077}
10078
10079
10080static uniform2iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10081
10082pub(crate) fn init_uniform2iv_methodinfo<D: DomTypes>() {
10083 uniform2iv_methodinfo.set(JSJitInfo {
10084 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10085 method: Some(uniform2iv::<D>)
10086 },
10087 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10088 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
10089 },
10090 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10091 _bitfield_align_1: [],
10092 _bitfield_1: __BindgenBitfieldUnit::new(
10093 new_jsjitinfo_bitfield_1!(
10094 JSJitInfo_OpType::Method as u8,
10095 JSJitInfo_AliasSet::AliasEverything as u8,
10096 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10097 false,
10098 false,
10099 false,
10100 false,
10101 false,
10102 false,
10103 0,
10104 ).to_ne_bytes()
10105 ),
10106});
10107}
10108unsafe extern "C" fn uniform3iv<D: DomTypes>
10109(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10110 let mut result = false;
10111 wrap_panic(&mut || result = (|| {
10112 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10113 let this = &*(this as *const D::WebGL2RenderingContext);
10114 let args = &*args;
10115 let argc = args.argc_;
10116
10117 if argc < 2 {
10118 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform3iv\".");
10119 return false;
10120 }
10121 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10122 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
10123 Ok(val) => val,
10124 Err(()) => {
10125 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
10126 return false;
10127
10128 }
10129 }
10130 )
10131 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
10132 None
10133 } else {
10134 throw_type_error(cx.raw_cx(), "Value is not an object.");
10135 return false;
10136
10137 };
10138 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
10139 Ok(ConversionResult::Success(value)) => value,
10140 Ok(ConversionResult::Failure(error)) => {
10141 throw_type_error(cx.raw_cx(), &error);
10142 return false;
10143
10144 }
10145 _ => {
10146 return false;
10147
10148 },
10149 }
10150 ;
10151 let arg2: u32 = if args.get(2).is_undefined() {
10152 0
10153 } else {
10154 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10155 Ok(ConversionResult::Success(value)) => value,
10156 Ok(ConversionResult::Failure(error)) => {
10157 throw_type_error(cx.raw_cx(), &error);
10158 return false;
10159
10160 }
10161 _ => {
10162 return false;
10163
10164 },
10165 }
10166
10167 };
10168 let arg3: u32 = if args.get(3).is_undefined() {
10169 0
10170 } else {
10171 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10172 Ok(ConversionResult::Success(value)) => value,
10173 Ok(ConversionResult::Failure(error)) => {
10174 throw_type_error(cx.raw_cx(), &error);
10175 return false;
10176
10177 }
10178 _ => {
10179 return false;
10180
10181 },
10182 }
10183
10184 };
10185 let result: () = this.Uniform3iv(arg0.as_deref(), arg1, arg2, arg3);
10186
10187 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10188 return true;
10189 })());
10190 result
10191}
10192
10193
10194static uniform3iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10195
10196pub(crate) fn init_uniform3iv_methodinfo<D: DomTypes>() {
10197 uniform3iv_methodinfo.set(JSJitInfo {
10198 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10199 method: Some(uniform3iv::<D>)
10200 },
10201 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10202 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
10203 },
10204 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10205 _bitfield_align_1: [],
10206 _bitfield_1: __BindgenBitfieldUnit::new(
10207 new_jsjitinfo_bitfield_1!(
10208 JSJitInfo_OpType::Method as u8,
10209 JSJitInfo_AliasSet::AliasEverything as u8,
10210 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10211 false,
10212 false,
10213 false,
10214 false,
10215 false,
10216 false,
10217 0,
10218 ).to_ne_bytes()
10219 ),
10220});
10221}
10222unsafe extern "C" fn uniform4iv<D: DomTypes>
10223(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10224 let mut result = false;
10225 wrap_panic(&mut || result = (|| {
10226 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10227 let this = &*(this as *const D::WebGL2RenderingContext);
10228 let args = &*args;
10229 let argc = args.argc_;
10230
10231 if argc < 2 {
10232 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform4iv\".");
10233 return false;
10234 }
10235 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10236 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
10237 Ok(val) => val,
10238 Err(()) => {
10239 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
10240 return false;
10241
10242 }
10243 }
10244 )
10245 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
10246 None
10247 } else {
10248 throw_type_error(cx.raw_cx(), "Value is not an object.");
10249 return false;
10250
10251 };
10252 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
10253 Ok(ConversionResult::Success(value)) => value,
10254 Ok(ConversionResult::Failure(error)) => {
10255 throw_type_error(cx.raw_cx(), &error);
10256 return false;
10257
10258 }
10259 _ => {
10260 return false;
10261
10262 },
10263 }
10264 ;
10265 let arg2: u32 = if args.get(2).is_undefined() {
10266 0
10267 } else {
10268 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10269 Ok(ConversionResult::Success(value)) => value,
10270 Ok(ConversionResult::Failure(error)) => {
10271 throw_type_error(cx.raw_cx(), &error);
10272 return false;
10273
10274 }
10275 _ => {
10276 return false;
10277
10278 },
10279 }
10280
10281 };
10282 let arg3: u32 = if args.get(3).is_undefined() {
10283 0
10284 } else {
10285 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10286 Ok(ConversionResult::Success(value)) => value,
10287 Ok(ConversionResult::Failure(error)) => {
10288 throw_type_error(cx.raw_cx(), &error);
10289 return false;
10290
10291 }
10292 _ => {
10293 return false;
10294
10295 },
10296 }
10297
10298 };
10299 let result: () = this.Uniform4iv(arg0.as_deref(), arg1, arg2, arg3);
10300
10301 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10302 return true;
10303 })());
10304 result
10305}
10306
10307
10308static uniform4iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10309
10310pub(crate) fn init_uniform4iv_methodinfo<D: DomTypes>() {
10311 uniform4iv_methodinfo.set(JSJitInfo {
10312 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10313 method: Some(uniform4iv::<D>)
10314 },
10315 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10316 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
10317 },
10318 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10319 _bitfield_align_1: [],
10320 _bitfield_1: __BindgenBitfieldUnit::new(
10321 new_jsjitinfo_bitfield_1!(
10322 JSJitInfo_OpType::Method as u8,
10323 JSJitInfo_AliasSet::AliasEverything as u8,
10324 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10325 false,
10326 false,
10327 false,
10328 false,
10329 false,
10330 false,
10331 0,
10332 ).to_ne_bytes()
10333 ),
10334});
10335}
10336unsafe extern "C" fn uniformMatrix2fv<D: DomTypes>
10337(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10338 let mut result = false;
10339 wrap_panic(&mut || result = (|| {
10340 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10341 let this = &*(this as *const D::WebGL2RenderingContext);
10342 let args = &*args;
10343 let argc = args.argc_;
10344
10345 if argc < 3 {
10346 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix2fv\".");
10347 return false;
10348 }
10349 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10350 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
10351 Ok(val) => val,
10352 Err(()) => {
10353 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
10354 return false;
10355
10356 }
10357 }
10358 )
10359 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
10360 None
10361 } else {
10362 throw_type_error(cx.raw_cx(), "Value is not an object.");
10363 return false;
10364
10365 };
10366 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
10367 Ok(ConversionResult::Success(value)) => value,
10368 Ok(ConversionResult::Failure(error)) => {
10369 throw_type_error(cx.raw_cx(), &error);
10370 return false;
10371
10372 }
10373 _ => {
10374 return false;
10375
10376 },
10377 }
10378 ;
10379 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
10380 Ok(ConversionResult::Success(value)) => value,
10381 Ok(ConversionResult::Failure(error)) => {
10382 throw_type_error(cx.raw_cx(), &error);
10383 return false;
10384
10385 }
10386 _ => {
10387 return false;
10388
10389 },
10390 }
10391 ;
10392 let arg3: u32 = if args.get(3).is_undefined() {
10393 0
10394 } else {
10395 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10396 Ok(ConversionResult::Success(value)) => value,
10397 Ok(ConversionResult::Failure(error)) => {
10398 throw_type_error(cx.raw_cx(), &error);
10399 return false;
10400
10401 }
10402 _ => {
10403 return false;
10404
10405 },
10406 }
10407
10408 };
10409 let arg4: u32 = if args.get(4).is_undefined() {
10410 0
10411 } else {
10412 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10413 Ok(ConversionResult::Success(value)) => value,
10414 Ok(ConversionResult::Failure(error)) => {
10415 throw_type_error(cx.raw_cx(), &error);
10416 return false;
10417
10418 }
10419 _ => {
10420 return false;
10421
10422 },
10423 }
10424
10425 };
10426 let result: () = this.UniformMatrix2fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
10427
10428 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10429 return true;
10430 })());
10431 result
10432}
10433
10434
10435static uniformMatrix2fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10436
10437pub(crate) fn init_uniformMatrix2fv_methodinfo<D: DomTypes>() {
10438 uniformMatrix2fv_methodinfo.set(JSJitInfo {
10439 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10440 method: Some(uniformMatrix2fv::<D>)
10441 },
10442 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10443 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
10444 },
10445 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10446 _bitfield_align_1: [],
10447 _bitfield_1: __BindgenBitfieldUnit::new(
10448 new_jsjitinfo_bitfield_1!(
10449 JSJitInfo_OpType::Method as u8,
10450 JSJitInfo_AliasSet::AliasEverything as u8,
10451 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10452 false,
10453 false,
10454 false,
10455 false,
10456 false,
10457 false,
10458 0,
10459 ).to_ne_bytes()
10460 ),
10461});
10462}
10463unsafe extern "C" fn uniformMatrix3fv<D: DomTypes>
10464(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10465 let mut result = false;
10466 wrap_panic(&mut || result = (|| {
10467 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10468 let this = &*(this as *const D::WebGL2RenderingContext);
10469 let args = &*args;
10470 let argc = args.argc_;
10471
10472 if argc < 3 {
10473 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix3fv\".");
10474 return false;
10475 }
10476 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10477 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
10478 Ok(val) => val,
10479 Err(()) => {
10480 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
10481 return false;
10482
10483 }
10484 }
10485 )
10486 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
10487 None
10488 } else {
10489 throw_type_error(cx.raw_cx(), "Value is not an object.");
10490 return false;
10491
10492 };
10493 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
10494 Ok(ConversionResult::Success(value)) => value,
10495 Ok(ConversionResult::Failure(error)) => {
10496 throw_type_error(cx.raw_cx(), &error);
10497 return false;
10498
10499 }
10500 _ => {
10501 return false;
10502
10503 },
10504 }
10505 ;
10506 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
10507 Ok(ConversionResult::Success(value)) => value,
10508 Ok(ConversionResult::Failure(error)) => {
10509 throw_type_error(cx.raw_cx(), &error);
10510 return false;
10511
10512 }
10513 _ => {
10514 return false;
10515
10516 },
10517 }
10518 ;
10519 let arg3: u32 = if args.get(3).is_undefined() {
10520 0
10521 } else {
10522 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10523 Ok(ConversionResult::Success(value)) => value,
10524 Ok(ConversionResult::Failure(error)) => {
10525 throw_type_error(cx.raw_cx(), &error);
10526 return false;
10527
10528 }
10529 _ => {
10530 return false;
10531
10532 },
10533 }
10534
10535 };
10536 let arg4: u32 = if args.get(4).is_undefined() {
10537 0
10538 } else {
10539 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10540 Ok(ConversionResult::Success(value)) => value,
10541 Ok(ConversionResult::Failure(error)) => {
10542 throw_type_error(cx.raw_cx(), &error);
10543 return false;
10544
10545 }
10546 _ => {
10547 return false;
10548
10549 },
10550 }
10551
10552 };
10553 let result: () = this.UniformMatrix3fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
10554
10555 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10556 return true;
10557 })());
10558 result
10559}
10560
10561
10562static uniformMatrix3fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10563
10564pub(crate) fn init_uniformMatrix3fv_methodinfo<D: DomTypes>() {
10565 uniformMatrix3fv_methodinfo.set(JSJitInfo {
10566 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10567 method: Some(uniformMatrix3fv::<D>)
10568 },
10569 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10570 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
10571 },
10572 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10573 _bitfield_align_1: [],
10574 _bitfield_1: __BindgenBitfieldUnit::new(
10575 new_jsjitinfo_bitfield_1!(
10576 JSJitInfo_OpType::Method as u8,
10577 JSJitInfo_AliasSet::AliasEverything as u8,
10578 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10579 false,
10580 false,
10581 false,
10582 false,
10583 false,
10584 false,
10585 0,
10586 ).to_ne_bytes()
10587 ),
10588});
10589}
10590unsafe extern "C" fn uniformMatrix4fv<D: DomTypes>
10591(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10592 let mut result = false;
10593 wrap_panic(&mut || result = (|| {
10594 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10595 let this = &*(this as *const D::WebGL2RenderingContext);
10596 let args = &*args;
10597 let argc = args.argc_;
10598
10599 if argc < 3 {
10600 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniformMatrix4fv\".");
10601 return false;
10602 }
10603 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10604 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
10605 Ok(val) => val,
10606 Err(()) => {
10607 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
10608 return false;
10609
10610 }
10611 }
10612 )
10613 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
10614 None
10615 } else {
10616 throw_type_error(cx.raw_cx(), "Value is not an object.");
10617 return false;
10618
10619 };
10620 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
10621 Ok(ConversionResult::Success(value)) => value,
10622 Ok(ConversionResult::Failure(error)) => {
10623 throw_type_error(cx.raw_cx(), &error);
10624 return false;
10625
10626 }
10627 _ => {
10628 return false;
10629
10630 },
10631 }
10632 ;
10633 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
10634 Ok(ConversionResult::Success(value)) => value,
10635 Ok(ConversionResult::Failure(error)) => {
10636 throw_type_error(cx.raw_cx(), &error);
10637 return false;
10638
10639 }
10640 _ => {
10641 return false;
10642
10643 },
10644 }
10645 ;
10646 let arg3: u32 = if args.get(3).is_undefined() {
10647 0
10648 } else {
10649 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10650 Ok(ConversionResult::Success(value)) => value,
10651 Ok(ConversionResult::Failure(error)) => {
10652 throw_type_error(cx.raw_cx(), &error);
10653 return false;
10654
10655 }
10656 _ => {
10657 return false;
10658
10659 },
10660 }
10661
10662 };
10663 let arg4: u32 = if args.get(4).is_undefined() {
10664 0
10665 } else {
10666 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10667 Ok(ConversionResult::Success(value)) => value,
10668 Ok(ConversionResult::Failure(error)) => {
10669 throw_type_error(cx.raw_cx(), &error);
10670 return false;
10671
10672 }
10673 _ => {
10674 return false;
10675
10676 },
10677 }
10678
10679 };
10680 let result: () = this.UniformMatrix4fv(arg0.as_deref(), arg1, arg2, arg3, arg4);
10681
10682 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10683 return true;
10684 })());
10685 result
10686}
10687
10688
10689static uniformMatrix4fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10690
10691pub(crate) fn init_uniformMatrix4fv_methodinfo<D: DomTypes>() {
10692 uniformMatrix4fv_methodinfo.set(JSJitInfo {
10693 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10694 method: Some(uniformMatrix4fv::<D>)
10695 },
10696 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10697 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
10698 },
10699 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10700 _bitfield_align_1: [],
10701 _bitfield_1: __BindgenBitfieldUnit::new(
10702 new_jsjitinfo_bitfield_1!(
10703 JSJitInfo_OpType::Method as u8,
10704 JSJitInfo_AliasSet::AliasEverything as u8,
10705 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10706 false,
10707 false,
10708 false,
10709 false,
10710 false,
10711 false,
10712 0,
10713 ).to_ne_bytes()
10714 ),
10715});
10716}
10717unsafe extern "C" fn readPixels<D: DomTypes>
10718(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10719 let mut result = false;
10720 wrap_panic(&mut || result = (|| {
10721 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10722 let this = &*(this as *const D::WebGL2RenderingContext);
10723 let args = &*args;
10724 let argc = args.argc_;
10725
10726 let argcount = cmp::min(argc, 8);
10727 match argcount {
10728 7 => {
10729 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
10730 Ok(ConversionResult::Success(value)) => value,
10731 Ok(ConversionResult::Failure(error)) => {
10732 throw_type_error(cx.raw_cx(), &error);
10733 return false;
10734
10735 }
10736 _ => {
10737 return false;
10738
10739 },
10740 }
10741 ;
10742 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
10743 Ok(ConversionResult::Success(value)) => value,
10744 Ok(ConversionResult::Failure(error)) => {
10745 throw_type_error(cx.raw_cx(), &error);
10746 return false;
10747
10748 }
10749 _ => {
10750 return false;
10751
10752 },
10753 }
10754 ;
10755 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10756 Ok(ConversionResult::Success(value)) => value,
10757 Ok(ConversionResult::Failure(error)) => {
10758 throw_type_error(cx.raw_cx(), &error);
10759 return false;
10760
10761 }
10762 _ => {
10763 return false;
10764
10765 },
10766 }
10767 ;
10768 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10769 Ok(ConversionResult::Success(value)) => value,
10770 Ok(ConversionResult::Failure(error)) => {
10771 throw_type_error(cx.raw_cx(), &error);
10772 return false;
10773
10774 }
10775 _ => {
10776 return false;
10777
10778 },
10779 }
10780 ;
10781 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10782 Ok(ConversionResult::Success(value)) => value,
10783 Ok(ConversionResult::Failure(error)) => {
10784 throw_type_error(cx.raw_cx(), &error);
10785 return false;
10786
10787 }
10788 _ => {
10789 return false;
10790
10791 },
10792 }
10793 ;
10794 let arg5: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
10795 Ok(ConversionResult::Success(value)) => value,
10796 Ok(ConversionResult::Failure(error)) => {
10797 throw_type_error(cx.raw_cx(), &error);
10798 return false;
10799
10800 }
10801 _ => {
10802 return false;
10803
10804 },
10805 }
10806 ;
10807 if HandleValue::from_raw(args.get(6)).get().is_null_or_undefined() {
10808 let arg6: Option<typedarray::ArrayBufferView> = if HandleValue::from_raw(args.get(6)).get().is_object() {
10809 Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(6)).get().to_object()) {
10810 Ok(val) => val,
10811 Err(()) => {
10812 throw_type_error(cx.raw_cx(), "value is not a typed array.");
10813 return false;
10814
10815 }
10816 }
10817 )
10818 } else if HandleValue::from_raw(args.get(6)).get().is_null_or_undefined() {
10819 None
10820 } else {
10821 throw_type_error(cx.raw_cx(), "Value is not an object.");
10822 return false;
10823
10824 };
10825 auto_root!(&in(cx) let arg6 = arg6);
10826 let result: () = this.ReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
10827
10828 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10829 return true;
10830 }
10831 if HandleValue::from_raw(args.get(6)).get().is_object() {
10832 '_block: {
10833 let arg6: Option<typedarray::ArrayBufferView> = Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(6)).get().to_object()) {
10834 Ok(val) => val,
10835 Err(()) => {
10836 break '_block;
10837 }
10838 }
10839 );
10840 auto_root!(&in(cx) let arg6 = arg6);
10841 let result: () = this.ReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
10842
10843 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10844 return true;
10845 }
10846 }
10847 let arg6: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
10848 Ok(ConversionResult::Success(value)) => value,
10849 Ok(ConversionResult::Failure(error)) => {
10850 throw_type_error(cx.raw_cx(), &error);
10851 return false;
10852
10853 }
10854 _ => {
10855 return false;
10856
10857 },
10858 }
10859 ;
10860 let result: () = this.ReadPixels_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
10861
10862 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10863 return true;
10864 }
10865 8 => {
10866 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
10867 Ok(ConversionResult::Success(value)) => value,
10868 Ok(ConversionResult::Failure(error)) => {
10869 throw_type_error(cx.raw_cx(), &error);
10870 return false;
10871
10872 }
10873 _ => {
10874 return false;
10875
10876 },
10877 }
10878 ;
10879 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
10880 Ok(ConversionResult::Success(value)) => value,
10881 Ok(ConversionResult::Failure(error)) => {
10882 throw_type_error(cx.raw_cx(), &error);
10883 return false;
10884
10885 }
10886 _ => {
10887 return false;
10888
10889 },
10890 }
10891 ;
10892 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10893 Ok(ConversionResult::Success(value)) => value,
10894 Ok(ConversionResult::Failure(error)) => {
10895 throw_type_error(cx.raw_cx(), &error);
10896 return false;
10897
10898 }
10899 _ => {
10900 return false;
10901
10902 },
10903 }
10904 ;
10905 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10906 Ok(ConversionResult::Success(value)) => value,
10907 Ok(ConversionResult::Failure(error)) => {
10908 throw_type_error(cx.raw_cx(), &error);
10909 return false;
10910
10911 }
10912 _ => {
10913 return false;
10914
10915 },
10916 }
10917 ;
10918 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10919 Ok(ConversionResult::Success(value)) => value,
10920 Ok(ConversionResult::Failure(error)) => {
10921 throw_type_error(cx.raw_cx(), &error);
10922 return false;
10923
10924 }
10925 _ => {
10926 return false;
10927
10928 },
10929 }
10930 ;
10931 let arg5: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
10932 Ok(ConversionResult::Success(value)) => value,
10933 Ok(ConversionResult::Failure(error)) => {
10934 throw_type_error(cx.raw_cx(), &error);
10935 return false;
10936
10937 }
10938 _ => {
10939 return false;
10940
10941 },
10942 }
10943 ;
10944 let arg6: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(6)).get().is_object() {
10945 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(6)).get().to_object()) {
10946 Ok(val) => val,
10947 Err(()) => {
10948 throw_type_error(cx.raw_cx(), "value is not a typed array.");
10949 return false;
10950
10951 }
10952 }
10953
10954 } else {
10955 throw_type_error(cx.raw_cx(), "Value is not an object.");
10956 return false;
10957
10958 };
10959 auto_root!(&in(cx) let arg6 = arg6);
10960 let arg7: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
10961 Ok(ConversionResult::Success(value)) => value,
10962 Ok(ConversionResult::Failure(error)) => {
10963 throw_type_error(cx.raw_cx(), &error);
10964 return false;
10965
10966 }
10967 _ => {
10968 return false;
10969
10970 },
10971 }
10972 ;
10973 let result: () = this.ReadPixels__(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
10974
10975 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10976 return true;
10977 }
10978 _ => {
10979 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.readPixels\".");
10980 return false;
10981 }
10982 }
10983 })());
10984 result
10985}
10986
10987
10988static readPixels_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10989
10990pub(crate) fn init_readPixels_methodinfo<D: DomTypes>() {
10991 readPixels_methodinfo.set(JSJitInfo {
10992 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10993 method: Some(readPixels::<D>)
10994 },
10995 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10996 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
10997 },
10998 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10999 _bitfield_align_1: [],
11000 _bitfield_1: __BindgenBitfieldUnit::new(
11001 new_jsjitinfo_bitfield_1!(
11002 JSJitInfo_OpType::Method as u8,
11003 JSJitInfo_AliasSet::AliasEverything as u8,
11004 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11005 false,
11006 false,
11007 false,
11008 false,
11009 false,
11010 false,
11011 0,
11012 ).to_ne_bytes()
11013 ),
11014});
11015}
11016unsafe extern "C" fn get_canvas<D: DomTypes>
11017(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11018 let mut result = false;
11019 wrap_panic(&mut || result = (|| {
11020 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11021 let this = &*(this as *const D::WebGL2RenderingContext);
11022 let result: GenericUnionTypes::HTMLCanvasElementOrOffscreenCanvas::<D> = this.Canvas();
11023
11024 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11025 return true;
11026 })());
11027 result
11028}
11029
11030
11031static canvas_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11032
11033pub(crate) fn init_canvas_getterinfo<D: DomTypes>() {
11034 canvas_getterinfo.set(JSJitInfo {
11035 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11036 getter: Some(get_canvas::<D>)
11037 },
11038 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11039 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11040 },
11041 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11042 _bitfield_align_1: [],
11043 _bitfield_1: __BindgenBitfieldUnit::new(
11044 new_jsjitinfo_bitfield_1!(
11045 JSJitInfo_OpType::Getter as u8,
11046 JSJitInfo_AliasSet::AliasEverything as u8,
11047 JSValueType::JSVAL_TYPE_OBJECT as u8,
11048 true,
11049 false,
11050 false,
11051 false,
11052 false,
11053 false,
11054 0,
11055 ).to_ne_bytes()
11056 ),
11057});
11058}
11059unsafe extern "C" fn get_drawingBufferWidth<D: DomTypes>
11060(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11061 let mut result = false;
11062 wrap_panic(&mut || result = (|| {
11063 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11064 let this = &*(this as *const D::WebGL2RenderingContext);
11065 let result: i32 = this.DrawingBufferWidth();
11066
11067 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11068 return true;
11069 })());
11070 result
11071}
11072
11073
11074static drawingBufferWidth_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11075
11076pub(crate) fn init_drawingBufferWidth_getterinfo<D: DomTypes>() {
11077 drawingBufferWidth_getterinfo.set(JSJitInfo {
11078 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11079 getter: Some(get_drawingBufferWidth::<D>)
11080 },
11081 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11082 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11083 },
11084 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11085 _bitfield_align_1: [],
11086 _bitfield_1: __BindgenBitfieldUnit::new(
11087 new_jsjitinfo_bitfield_1!(
11088 JSJitInfo_OpType::Getter as u8,
11089 JSJitInfo_AliasSet::AliasEverything as u8,
11090 JSValueType::JSVAL_TYPE_INT32 as u8,
11091 true,
11092 false,
11093 false,
11094 false,
11095 false,
11096 false,
11097 0,
11098 ).to_ne_bytes()
11099 ),
11100});
11101}
11102unsafe extern "C" fn get_drawingBufferHeight<D: DomTypes>
11103(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
11104 let mut result = false;
11105 wrap_panic(&mut || result = (|| {
11106 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11107 let this = &*(this as *const D::WebGL2RenderingContext);
11108 let result: i32 = this.DrawingBufferHeight();
11109
11110 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11111 return true;
11112 })());
11113 result
11114}
11115
11116
11117static drawingBufferHeight_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11118
11119pub(crate) fn init_drawingBufferHeight_getterinfo<D: DomTypes>() {
11120 drawingBufferHeight_getterinfo.set(JSJitInfo {
11121 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11122 getter: Some(get_drawingBufferHeight::<D>)
11123 },
11124 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11125 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11126 },
11127 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11128 _bitfield_align_1: [],
11129 _bitfield_1: __BindgenBitfieldUnit::new(
11130 new_jsjitinfo_bitfield_1!(
11131 JSJitInfo_OpType::Getter as u8,
11132 JSJitInfo_AliasSet::AliasEverything as u8,
11133 JSValueType::JSVAL_TYPE_INT32 as u8,
11134 true,
11135 false,
11136 false,
11137 false,
11138 false,
11139 false,
11140 0,
11141 ).to_ne_bytes()
11142 ),
11143});
11144}
11145unsafe extern "C" fn getContextAttributes<D: DomTypes>
11146(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11147 let mut result = false;
11148 wrap_panic(&mut || result = (|| {
11149 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11150 let this = &*(this as *const D::WebGL2RenderingContext);
11151 let args = &*args;
11152 let argc = args.argc_;
11153 let result: Option<WebGLContextAttributes> = this.GetContextAttributes();
11154
11155 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11156 return true;
11157 })());
11158 result
11159}
11160
11161
11162static getContextAttributes_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11163
11164pub(crate) fn init_getContextAttributes_methodinfo<D: DomTypes>() {
11165 getContextAttributes_methodinfo.set(JSJitInfo {
11166 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11167 method: Some(getContextAttributes::<D>)
11168 },
11169 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11170 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11171 },
11172 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11173 _bitfield_align_1: [],
11174 _bitfield_1: __BindgenBitfieldUnit::new(
11175 new_jsjitinfo_bitfield_1!(
11176 JSJitInfo_OpType::Method as u8,
11177 JSJitInfo_AliasSet::AliasEverything as u8,
11178 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11179 true,
11180 false,
11181 false,
11182 false,
11183 false,
11184 false,
11185 0,
11186 ).to_ne_bytes()
11187 ),
11188});
11189}
11190unsafe extern "C" fn isContextLost<D: DomTypes>
11191(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11192 let mut result = false;
11193 wrap_panic(&mut || result = (|| {
11194 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11195 let this = &*(this as *const D::WebGL2RenderingContext);
11196 let args = &*args;
11197 let argc = args.argc_;
11198 let result: bool = this.IsContextLost();
11199
11200 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11201 return true;
11202 })());
11203 result
11204}
11205
11206
11207static isContextLost_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11208
11209pub(crate) fn init_isContextLost_methodinfo<D: DomTypes>() {
11210 isContextLost_methodinfo.set(JSJitInfo {
11211 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11212 method: Some(isContextLost::<D>)
11213 },
11214 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11215 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11216 },
11217 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11218 _bitfield_align_1: [],
11219 _bitfield_1: __BindgenBitfieldUnit::new(
11220 new_jsjitinfo_bitfield_1!(
11221 JSJitInfo_OpType::Method as u8,
11222 JSJitInfo_AliasSet::AliasEverything as u8,
11223 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
11224 true,
11225 false,
11226 false,
11227 false,
11228 false,
11229 false,
11230 0,
11231 ).to_ne_bytes()
11232 ),
11233});
11234}
11235unsafe extern "C" fn getSupportedExtensions<D: DomTypes>
11236(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11237 let mut result = false;
11238 wrap_panic(&mut || result = (|| {
11239 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11240 let this = &*(this as *const D::WebGL2RenderingContext);
11241 let args = &*args;
11242 let argc = args.argc_;
11243 let result: Option<Vec<DOMString>> = this.GetSupportedExtensions();
11244
11245 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11246 return true;
11247 })());
11248 result
11249}
11250
11251
11252static getSupportedExtensions_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11253
11254pub(crate) fn init_getSupportedExtensions_methodinfo<D: DomTypes>() {
11255 getSupportedExtensions_methodinfo.set(JSJitInfo {
11256 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11257 method: Some(getSupportedExtensions::<D>)
11258 },
11259 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11260 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11261 },
11262 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11263 _bitfield_align_1: [],
11264 _bitfield_1: __BindgenBitfieldUnit::new(
11265 new_jsjitinfo_bitfield_1!(
11266 JSJitInfo_OpType::Method as u8,
11267 JSJitInfo_AliasSet::AliasEverything as u8,
11268 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11269 true,
11270 false,
11271 false,
11272 false,
11273 false,
11274 false,
11275 0,
11276 ).to_ne_bytes()
11277 ),
11278});
11279}
11280unsafe extern "C" fn getExtension<D: DomTypes>
11281(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11282 let mut result = false;
11283 wrap_panic(&mut || result = (|| {
11284 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11285 let this = &*(this as *const D::WebGL2RenderingContext);
11286 let args = &*args;
11287 let argc = args.argc_;
11288
11289 if argc < 1 {
11290 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getExtension\".");
11291 return false;
11292 }
11293 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
11294 Ok(ConversionResult::Success(value)) => value,
11295 Ok(ConversionResult::Failure(error)) => {
11296 throw_type_error(cx.raw_cx(), &error);
11297 return false;
11298
11299 }
11300 _ => {
11301 return false;
11302
11303 },
11304 }
11305 ;
11306 let result: Option<NonNull<JSObject>> = this.GetExtension(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
11307
11308 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11309 return true;
11310 })());
11311 result
11312}
11313
11314
11315static getExtension_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11316
11317pub(crate) fn init_getExtension_methodinfo<D: DomTypes>() {
11318 getExtension_methodinfo.set(JSJitInfo {
11319 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11320 method: Some(getExtension::<D>)
11321 },
11322 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11323 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11324 },
11325 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11326 _bitfield_align_1: [],
11327 _bitfield_1: __BindgenBitfieldUnit::new(
11328 new_jsjitinfo_bitfield_1!(
11329 JSJitInfo_OpType::Method as u8,
11330 JSJitInfo_AliasSet::AliasEverything as u8,
11331 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11332 false,
11333 false,
11334 false,
11335 false,
11336 false,
11337 false,
11338 0,
11339 ).to_ne_bytes()
11340 ),
11341});
11342}
11343unsafe extern "C" fn activeTexture<D: DomTypes>
11344(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11345 let mut result = false;
11346 wrap_panic(&mut || result = (|| {
11347 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11348 let this = &*(this as *const D::WebGL2RenderingContext);
11349 let args = &*args;
11350 let argc = args.argc_;
11351
11352 if argc < 1 {
11353 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.activeTexture\".");
11354 return false;
11355 }
11356 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11357 Ok(ConversionResult::Success(value)) => value,
11358 Ok(ConversionResult::Failure(error)) => {
11359 throw_type_error(cx.raw_cx(), &error);
11360 return false;
11361
11362 }
11363 _ => {
11364 return false;
11365
11366 },
11367 }
11368 ;
11369 let result: () = this.ActiveTexture(arg0);
11370
11371 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11372 return true;
11373 })());
11374 result
11375}
11376
11377
11378static activeTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11379
11380pub(crate) fn init_activeTexture_methodinfo<D: DomTypes>() {
11381 activeTexture_methodinfo.set(JSJitInfo {
11382 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11383 method: Some(activeTexture::<D>)
11384 },
11385 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11386 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11387 },
11388 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11389 _bitfield_align_1: [],
11390 _bitfield_1: __BindgenBitfieldUnit::new(
11391 new_jsjitinfo_bitfield_1!(
11392 JSJitInfo_OpType::Method as u8,
11393 JSJitInfo_AliasSet::AliasEverything as u8,
11394 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11395 false,
11396 false,
11397 false,
11398 false,
11399 false,
11400 false,
11401 0,
11402 ).to_ne_bytes()
11403 ),
11404});
11405}
11406unsafe extern "C" fn attachShader<D: DomTypes>
11407(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11408 let mut result = false;
11409 wrap_panic(&mut || result = (|| {
11410 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11411 let this = &*(this as *const D::WebGL2RenderingContext);
11412 let args = &*args;
11413 let argc = args.argc_;
11414
11415 if argc < 2 {
11416 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.attachShader\".");
11417 return false;
11418 }
11419 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11420 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11421 Ok(val) => val,
11422 Err(()) => {
11423 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
11424 return false;
11425
11426 }
11427 }
11428
11429 } else {
11430 throw_type_error(cx.raw_cx(), "Value is not an object.");
11431 return false;
11432
11433 };
11434 let arg1: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(1)).get().is_object() {
11435 match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
11436 Ok(val) => val,
11437 Err(()) => {
11438 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
11439 return false;
11440
11441 }
11442 }
11443
11444 } else {
11445 throw_type_error(cx.raw_cx(), "Value is not an object.");
11446 return false;
11447
11448 };
11449 let result: () = this.AttachShader(&arg0, &arg1);
11450
11451 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11452 return true;
11453 })());
11454 result
11455}
11456
11457
11458static attachShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11459
11460pub(crate) fn init_attachShader_methodinfo<D: DomTypes>() {
11461 attachShader_methodinfo.set(JSJitInfo {
11462 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11463 method: Some(attachShader::<D>)
11464 },
11465 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11466 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11467 },
11468 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11469 _bitfield_align_1: [],
11470 _bitfield_1: __BindgenBitfieldUnit::new(
11471 new_jsjitinfo_bitfield_1!(
11472 JSJitInfo_OpType::Method as u8,
11473 JSJitInfo_AliasSet::AliasEverything as u8,
11474 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11475 false,
11476 false,
11477 false,
11478 false,
11479 false,
11480 false,
11481 0,
11482 ).to_ne_bytes()
11483 ),
11484});
11485}
11486unsafe extern "C" fn bindAttribLocation<D: DomTypes>
11487(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11488 let mut result = false;
11489 wrap_panic(&mut || result = (|| {
11490 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11491 let this = &*(this as *const D::WebGL2RenderingContext);
11492 let args = &*args;
11493 let argc = args.argc_;
11494
11495 if argc < 3 {
11496 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindAttribLocation\".");
11497 return false;
11498 }
11499 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11500 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11501 Ok(val) => val,
11502 Err(()) => {
11503 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
11504 return false;
11505
11506 }
11507 }
11508
11509 } else {
11510 throw_type_error(cx.raw_cx(), "Value is not an object.");
11511 return false;
11512
11513 };
11514 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
11515 Ok(ConversionResult::Success(value)) => value,
11516 Ok(ConversionResult::Failure(error)) => {
11517 throw_type_error(cx.raw_cx(), &error);
11518 return false;
11519
11520 }
11521 _ => {
11522 return false;
11523
11524 },
11525 }
11526 ;
11527 let arg2: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), StringificationBehavior::Default) {
11528 Ok(ConversionResult::Success(value)) => value,
11529 Ok(ConversionResult::Failure(error)) => {
11530 throw_type_error(cx.raw_cx(), &error);
11531 return false;
11532
11533 }
11534 _ => {
11535 return false;
11536
11537 },
11538 }
11539 ;
11540 let result: () = this.BindAttribLocation(&arg0, arg1, arg2);
11541
11542 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11543 return true;
11544 })());
11545 result
11546}
11547
11548
11549static bindAttribLocation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11550
11551pub(crate) fn init_bindAttribLocation_methodinfo<D: DomTypes>() {
11552 bindAttribLocation_methodinfo.set(JSJitInfo {
11553 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11554 method: Some(bindAttribLocation::<D>)
11555 },
11556 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11557 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11558 },
11559 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11560 _bitfield_align_1: [],
11561 _bitfield_1: __BindgenBitfieldUnit::new(
11562 new_jsjitinfo_bitfield_1!(
11563 JSJitInfo_OpType::Method as u8,
11564 JSJitInfo_AliasSet::AliasEverything as u8,
11565 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11566 false,
11567 false,
11568 false,
11569 false,
11570 false,
11571 false,
11572 0,
11573 ).to_ne_bytes()
11574 ),
11575});
11576}
11577unsafe extern "C" fn bindBuffer<D: DomTypes>
11578(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11579 let mut result = false;
11580 wrap_panic(&mut || result = (|| {
11581 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11582 let this = &*(this as *const D::WebGL2RenderingContext);
11583 let args = &*args;
11584 let argc = args.argc_;
11585
11586 if argc < 2 {
11587 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindBuffer\".");
11588 return false;
11589 }
11590 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11591 Ok(ConversionResult::Success(value)) => value,
11592 Ok(ConversionResult::Failure(error)) => {
11593 throw_type_error(cx.raw_cx(), &error);
11594 return false;
11595
11596 }
11597 _ => {
11598 return false;
11599
11600 },
11601 }
11602 ;
11603 let arg1: Option<DomRoot<D::WebGLBuffer>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
11604 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
11605 Ok(val) => val,
11606 Err(()) => {
11607 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLBuffer.");
11608 return false;
11609
11610 }
11611 }
11612 )
11613 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
11614 None
11615 } else {
11616 throw_type_error(cx.raw_cx(), "Value is not an object.");
11617 return false;
11618
11619 };
11620 let result: () = this.BindBuffer(arg0, arg1.as_deref());
11621
11622 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11623 return true;
11624 })());
11625 result
11626}
11627
11628
11629static bindBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11630
11631pub(crate) fn init_bindBuffer_methodinfo<D: DomTypes>() {
11632 bindBuffer_methodinfo.set(JSJitInfo {
11633 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11634 method: Some(bindBuffer::<D>)
11635 },
11636 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11637 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11638 },
11639 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11640 _bitfield_align_1: [],
11641 _bitfield_1: __BindgenBitfieldUnit::new(
11642 new_jsjitinfo_bitfield_1!(
11643 JSJitInfo_OpType::Method as u8,
11644 JSJitInfo_AliasSet::AliasEverything as u8,
11645 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11646 false,
11647 false,
11648 false,
11649 false,
11650 false,
11651 false,
11652 0,
11653 ).to_ne_bytes()
11654 ),
11655});
11656}
11657unsafe extern "C" fn bindFramebuffer<D: DomTypes>
11658(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11659 let mut result = false;
11660 wrap_panic(&mut || result = (|| {
11661 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11662 let this = &*(this as *const D::WebGL2RenderingContext);
11663 let args = &*args;
11664 let argc = args.argc_;
11665
11666 if argc < 2 {
11667 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindFramebuffer\".");
11668 return false;
11669 }
11670 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11671 Ok(ConversionResult::Success(value)) => value,
11672 Ok(ConversionResult::Failure(error)) => {
11673 throw_type_error(cx.raw_cx(), &error);
11674 return false;
11675
11676 }
11677 _ => {
11678 return false;
11679
11680 },
11681 }
11682 ;
11683 let arg1: Option<DomRoot<D::WebGLFramebuffer>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
11684 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
11685 Ok(val) => val,
11686 Err(()) => {
11687 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLFramebuffer.");
11688 return false;
11689
11690 }
11691 }
11692 )
11693 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
11694 None
11695 } else {
11696 throw_type_error(cx.raw_cx(), "Value is not an object.");
11697 return false;
11698
11699 };
11700 let result: () = this.BindFramebuffer(arg0, arg1.as_deref());
11701
11702 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11703 return true;
11704 })());
11705 result
11706}
11707
11708
11709static bindFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11710
11711pub(crate) fn init_bindFramebuffer_methodinfo<D: DomTypes>() {
11712 bindFramebuffer_methodinfo.set(JSJitInfo {
11713 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11714 method: Some(bindFramebuffer::<D>)
11715 },
11716 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11717 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11718 },
11719 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11720 _bitfield_align_1: [],
11721 _bitfield_1: __BindgenBitfieldUnit::new(
11722 new_jsjitinfo_bitfield_1!(
11723 JSJitInfo_OpType::Method as u8,
11724 JSJitInfo_AliasSet::AliasEverything as u8,
11725 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11726 false,
11727 false,
11728 false,
11729 false,
11730 false,
11731 false,
11732 0,
11733 ).to_ne_bytes()
11734 ),
11735});
11736}
11737unsafe extern "C" fn bindRenderbuffer<D: DomTypes>
11738(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11739 let mut result = false;
11740 wrap_panic(&mut || result = (|| {
11741 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11742 let this = &*(this as *const D::WebGL2RenderingContext);
11743 let args = &*args;
11744 let argc = args.argc_;
11745
11746 if argc < 2 {
11747 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindRenderbuffer\".");
11748 return false;
11749 }
11750 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11751 Ok(ConversionResult::Success(value)) => value,
11752 Ok(ConversionResult::Failure(error)) => {
11753 throw_type_error(cx.raw_cx(), &error);
11754 return false;
11755
11756 }
11757 _ => {
11758 return false;
11759
11760 },
11761 }
11762 ;
11763 let arg1: Option<DomRoot<D::WebGLRenderbuffer>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
11764 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
11765 Ok(val) => val,
11766 Err(()) => {
11767 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLRenderbuffer.");
11768 return false;
11769
11770 }
11771 }
11772 )
11773 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
11774 None
11775 } else {
11776 throw_type_error(cx.raw_cx(), "Value is not an object.");
11777 return false;
11778
11779 };
11780 let result: () = this.BindRenderbuffer(arg0, arg1.as_deref());
11781
11782 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11783 return true;
11784 })());
11785 result
11786}
11787
11788
11789static bindRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11790
11791pub(crate) fn init_bindRenderbuffer_methodinfo<D: DomTypes>() {
11792 bindRenderbuffer_methodinfo.set(JSJitInfo {
11793 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11794 method: Some(bindRenderbuffer::<D>)
11795 },
11796 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11797 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11798 },
11799 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11800 _bitfield_align_1: [],
11801 _bitfield_1: __BindgenBitfieldUnit::new(
11802 new_jsjitinfo_bitfield_1!(
11803 JSJitInfo_OpType::Method as u8,
11804 JSJitInfo_AliasSet::AliasEverything as u8,
11805 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11806 false,
11807 false,
11808 false,
11809 false,
11810 false,
11811 false,
11812 0,
11813 ).to_ne_bytes()
11814 ),
11815});
11816}
11817unsafe extern "C" fn bindTexture<D: DomTypes>
11818(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11819 let mut result = false;
11820 wrap_panic(&mut || result = (|| {
11821 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11822 let this = &*(this as *const D::WebGL2RenderingContext);
11823 let args = &*args;
11824 let argc = args.argc_;
11825
11826 if argc < 2 {
11827 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.bindTexture\".");
11828 return false;
11829 }
11830 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11831 Ok(ConversionResult::Success(value)) => value,
11832 Ok(ConversionResult::Failure(error)) => {
11833 throw_type_error(cx.raw_cx(), &error);
11834 return false;
11835
11836 }
11837 _ => {
11838 return false;
11839
11840 },
11841 }
11842 ;
11843 let arg1: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
11844 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
11845 Ok(val) => val,
11846 Err(()) => {
11847 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
11848 return false;
11849
11850 }
11851 }
11852 )
11853 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
11854 None
11855 } else {
11856 throw_type_error(cx.raw_cx(), "Value is not an object.");
11857 return false;
11858
11859 };
11860 let result: () = this.BindTexture(arg0, arg1.as_deref());
11861
11862 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11863 return true;
11864 })());
11865 result
11866}
11867
11868
11869static bindTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11870
11871pub(crate) fn init_bindTexture_methodinfo<D: DomTypes>() {
11872 bindTexture_methodinfo.set(JSJitInfo {
11873 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11874 method: Some(bindTexture::<D>)
11875 },
11876 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11877 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11878 },
11879 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11880 _bitfield_align_1: [],
11881 _bitfield_1: __BindgenBitfieldUnit::new(
11882 new_jsjitinfo_bitfield_1!(
11883 JSJitInfo_OpType::Method as u8,
11884 JSJitInfo_AliasSet::AliasEverything as u8,
11885 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11886 false,
11887 false,
11888 false,
11889 false,
11890 false,
11891 false,
11892 0,
11893 ).to_ne_bytes()
11894 ),
11895});
11896}
11897unsafe extern "C" fn blendColor<D: DomTypes>
11898(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11899 let mut result = false;
11900 wrap_panic(&mut || result = (|| {
11901 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11902 let this = &*(this as *const D::WebGL2RenderingContext);
11903 let args = &*args;
11904 let argc = args.argc_;
11905
11906 if argc < 4 {
11907 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.blendColor\".");
11908 return false;
11909 }
11910 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
11911 Ok(ConversionResult::Success(value)) => value,
11912 Ok(ConversionResult::Failure(error)) => {
11913 throw_type_error(cx.raw_cx(), &error);
11914 return false;
11915
11916 }
11917 _ => {
11918 return false;
11919
11920 },
11921 }
11922 ;
11923 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11924 Ok(ConversionResult::Success(value)) => value,
11925 Ok(ConversionResult::Failure(error)) => {
11926 throw_type_error(cx.raw_cx(), &error);
11927 return false;
11928
11929 }
11930 _ => {
11931 return false;
11932
11933 },
11934 }
11935 ;
11936 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
11937 Ok(ConversionResult::Success(value)) => value,
11938 Ok(ConversionResult::Failure(error)) => {
11939 throw_type_error(cx.raw_cx(), &error);
11940 return false;
11941
11942 }
11943 _ => {
11944 return false;
11945
11946 },
11947 }
11948 ;
11949 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
11950 Ok(ConversionResult::Success(value)) => value,
11951 Ok(ConversionResult::Failure(error)) => {
11952 throw_type_error(cx.raw_cx(), &error);
11953 return false;
11954
11955 }
11956 _ => {
11957 return false;
11958
11959 },
11960 }
11961 ;
11962 let result: () = this.BlendColor(arg0, arg1, arg2, arg3);
11963
11964 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11965 return true;
11966 })());
11967 result
11968}
11969
11970
11971static blendColor_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11972
11973pub(crate) fn init_blendColor_methodinfo<D: DomTypes>() {
11974 blendColor_methodinfo.set(JSJitInfo {
11975 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11976 method: Some(blendColor::<D>)
11977 },
11978 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11979 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
11980 },
11981 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11982 _bitfield_align_1: [],
11983 _bitfield_1: __BindgenBitfieldUnit::new(
11984 new_jsjitinfo_bitfield_1!(
11985 JSJitInfo_OpType::Method as u8,
11986 JSJitInfo_AliasSet::AliasEverything as u8,
11987 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11988 false,
11989 false,
11990 false,
11991 false,
11992 false,
11993 false,
11994 0,
11995 ).to_ne_bytes()
11996 ),
11997});
11998}
11999unsafe extern "C" fn blendEquation<D: DomTypes>
12000(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12001 let mut result = false;
12002 wrap_panic(&mut || result = (|| {
12003 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12004 let this = &*(this as *const D::WebGL2RenderingContext);
12005 let args = &*args;
12006 let argc = args.argc_;
12007
12008 if argc < 1 {
12009 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.blendEquation\".");
12010 return false;
12011 }
12012 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
12013 Ok(ConversionResult::Success(value)) => value,
12014 Ok(ConversionResult::Failure(error)) => {
12015 throw_type_error(cx.raw_cx(), &error);
12016 return false;
12017
12018 }
12019 _ => {
12020 return false;
12021
12022 },
12023 }
12024 ;
12025 let result: () = this.BlendEquation(arg0);
12026
12027 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12028 return true;
12029 })());
12030 result
12031}
12032
12033
12034static blendEquation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12035
12036pub(crate) fn init_blendEquation_methodinfo<D: DomTypes>() {
12037 blendEquation_methodinfo.set(JSJitInfo {
12038 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12039 method: Some(blendEquation::<D>)
12040 },
12041 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12042 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12043 },
12044 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12045 _bitfield_align_1: [],
12046 _bitfield_1: __BindgenBitfieldUnit::new(
12047 new_jsjitinfo_bitfield_1!(
12048 JSJitInfo_OpType::Method as u8,
12049 JSJitInfo_AliasSet::AliasEverything as u8,
12050 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12051 false,
12052 false,
12053 false,
12054 false,
12055 false,
12056 false,
12057 0,
12058 ).to_ne_bytes()
12059 ),
12060});
12061}
12062unsafe extern "C" fn blendEquationSeparate<D: DomTypes>
12063(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12064 let mut result = false;
12065 wrap_panic(&mut || result = (|| {
12066 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12067 let this = &*(this as *const D::WebGL2RenderingContext);
12068 let args = &*args;
12069 let argc = args.argc_;
12070
12071 if argc < 2 {
12072 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.blendEquationSeparate\".");
12073 return false;
12074 }
12075 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
12076 Ok(ConversionResult::Success(value)) => value,
12077 Ok(ConversionResult::Failure(error)) => {
12078 throw_type_error(cx.raw_cx(), &error);
12079 return false;
12080
12081 }
12082 _ => {
12083 return false;
12084
12085 },
12086 }
12087 ;
12088 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
12089 Ok(ConversionResult::Success(value)) => value,
12090 Ok(ConversionResult::Failure(error)) => {
12091 throw_type_error(cx.raw_cx(), &error);
12092 return false;
12093
12094 }
12095 _ => {
12096 return false;
12097
12098 },
12099 }
12100 ;
12101 let result: () = this.BlendEquationSeparate(arg0, arg1);
12102
12103 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12104 return true;
12105 })());
12106 result
12107}
12108
12109
12110static blendEquationSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12111
12112pub(crate) fn init_blendEquationSeparate_methodinfo<D: DomTypes>() {
12113 blendEquationSeparate_methodinfo.set(JSJitInfo {
12114 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12115 method: Some(blendEquationSeparate::<D>)
12116 },
12117 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12118 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12119 },
12120 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12121 _bitfield_align_1: [],
12122 _bitfield_1: __BindgenBitfieldUnit::new(
12123 new_jsjitinfo_bitfield_1!(
12124 JSJitInfo_OpType::Method as u8,
12125 JSJitInfo_AliasSet::AliasEverything as u8,
12126 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12127 false,
12128 false,
12129 false,
12130 false,
12131 false,
12132 false,
12133 0,
12134 ).to_ne_bytes()
12135 ),
12136});
12137}
12138unsafe extern "C" fn blendFunc<D: DomTypes>
12139(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12140 let mut result = false;
12141 wrap_panic(&mut || result = (|| {
12142 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12143 let this = &*(this as *const D::WebGL2RenderingContext);
12144 let args = &*args;
12145 let argc = args.argc_;
12146
12147 if argc < 2 {
12148 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.blendFunc\".");
12149 return false;
12150 }
12151 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
12152 Ok(ConversionResult::Success(value)) => value,
12153 Ok(ConversionResult::Failure(error)) => {
12154 throw_type_error(cx.raw_cx(), &error);
12155 return false;
12156
12157 }
12158 _ => {
12159 return false;
12160
12161 },
12162 }
12163 ;
12164 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
12165 Ok(ConversionResult::Success(value)) => value,
12166 Ok(ConversionResult::Failure(error)) => {
12167 throw_type_error(cx.raw_cx(), &error);
12168 return false;
12169
12170 }
12171 _ => {
12172 return false;
12173
12174 },
12175 }
12176 ;
12177 let result: () = this.BlendFunc(arg0, arg1);
12178
12179 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12180 return true;
12181 })());
12182 result
12183}
12184
12185
12186static blendFunc_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12187
12188pub(crate) fn init_blendFunc_methodinfo<D: DomTypes>() {
12189 blendFunc_methodinfo.set(JSJitInfo {
12190 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12191 method: Some(blendFunc::<D>)
12192 },
12193 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12194 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12195 },
12196 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12197 _bitfield_align_1: [],
12198 _bitfield_1: __BindgenBitfieldUnit::new(
12199 new_jsjitinfo_bitfield_1!(
12200 JSJitInfo_OpType::Method as u8,
12201 JSJitInfo_AliasSet::AliasEverything as u8,
12202 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12203 false,
12204 false,
12205 false,
12206 false,
12207 false,
12208 false,
12209 0,
12210 ).to_ne_bytes()
12211 ),
12212});
12213}
12214unsafe extern "C" fn blendFuncSeparate<D: DomTypes>
12215(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12216 let mut result = false;
12217 wrap_panic(&mut || result = (|| {
12218 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12219 let this = &*(this as *const D::WebGL2RenderingContext);
12220 let args = &*args;
12221 let argc = args.argc_;
12222
12223 if argc < 4 {
12224 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.blendFuncSeparate\".");
12225 return false;
12226 }
12227 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
12228 Ok(ConversionResult::Success(value)) => value,
12229 Ok(ConversionResult::Failure(error)) => {
12230 throw_type_error(cx.raw_cx(), &error);
12231 return false;
12232
12233 }
12234 _ => {
12235 return false;
12236
12237 },
12238 }
12239 ;
12240 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
12241 Ok(ConversionResult::Success(value)) => value,
12242 Ok(ConversionResult::Failure(error)) => {
12243 throw_type_error(cx.raw_cx(), &error);
12244 return false;
12245
12246 }
12247 _ => {
12248 return false;
12249
12250 },
12251 }
12252 ;
12253 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
12254 Ok(ConversionResult::Success(value)) => value,
12255 Ok(ConversionResult::Failure(error)) => {
12256 throw_type_error(cx.raw_cx(), &error);
12257 return false;
12258
12259 }
12260 _ => {
12261 return false;
12262
12263 },
12264 }
12265 ;
12266 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
12267 Ok(ConversionResult::Success(value)) => value,
12268 Ok(ConversionResult::Failure(error)) => {
12269 throw_type_error(cx.raw_cx(), &error);
12270 return false;
12271
12272 }
12273 _ => {
12274 return false;
12275
12276 },
12277 }
12278 ;
12279 let result: () = this.BlendFuncSeparate(arg0, arg1, arg2, arg3);
12280
12281 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12282 return true;
12283 })());
12284 result
12285}
12286
12287
12288static blendFuncSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12289
12290pub(crate) fn init_blendFuncSeparate_methodinfo<D: DomTypes>() {
12291 blendFuncSeparate_methodinfo.set(JSJitInfo {
12292 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12293 method: Some(blendFuncSeparate::<D>)
12294 },
12295 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12296 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12297 },
12298 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12299 _bitfield_align_1: [],
12300 _bitfield_1: __BindgenBitfieldUnit::new(
12301 new_jsjitinfo_bitfield_1!(
12302 JSJitInfo_OpType::Method as u8,
12303 JSJitInfo_AliasSet::AliasEverything as u8,
12304 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12305 false,
12306 false,
12307 false,
12308 false,
12309 false,
12310 false,
12311 0,
12312 ).to_ne_bytes()
12313 ),
12314});
12315}
12316unsafe extern "C" fn checkFramebufferStatus<D: DomTypes>
12317(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12318 let mut result = false;
12319 wrap_panic(&mut || result = (|| {
12320 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12321 let this = &*(this as *const D::WebGL2RenderingContext);
12322 let args = &*args;
12323 let argc = args.argc_;
12324
12325 if argc < 1 {
12326 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.checkFramebufferStatus\".");
12327 return false;
12328 }
12329 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
12330 Ok(ConversionResult::Success(value)) => value,
12331 Ok(ConversionResult::Failure(error)) => {
12332 throw_type_error(cx.raw_cx(), &error);
12333 return false;
12334
12335 }
12336 _ => {
12337 return false;
12338
12339 },
12340 }
12341 ;
12342 let result: u32 = this.CheckFramebufferStatus(arg0);
12343
12344 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12345 return true;
12346 })());
12347 result
12348}
12349
12350
12351static checkFramebufferStatus_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12352
12353pub(crate) fn init_checkFramebufferStatus_methodinfo<D: DomTypes>() {
12354 checkFramebufferStatus_methodinfo.set(JSJitInfo {
12355 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12356 method: Some(checkFramebufferStatus::<D>)
12357 },
12358 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12359 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12360 },
12361 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12362 _bitfield_align_1: [],
12363 _bitfield_1: __BindgenBitfieldUnit::new(
12364 new_jsjitinfo_bitfield_1!(
12365 JSJitInfo_OpType::Method as u8,
12366 JSJitInfo_AliasSet::AliasEverything as u8,
12367 JSValueType::JSVAL_TYPE_DOUBLE as u8,
12368 false,
12369 false,
12370 false,
12371 false,
12372 false,
12373 false,
12374 0,
12375 ).to_ne_bytes()
12376 ),
12377});
12378}
12379unsafe extern "C" fn clear<D: DomTypes>
12380(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12381 let mut result = false;
12382 wrap_panic(&mut || result = (|| {
12383 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12384 let this = &*(this as *const D::WebGL2RenderingContext);
12385 let args = &*args;
12386 let argc = args.argc_;
12387
12388 if argc < 1 {
12389 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clear\".");
12390 return false;
12391 }
12392 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
12393 Ok(ConversionResult::Success(value)) => value,
12394 Ok(ConversionResult::Failure(error)) => {
12395 throw_type_error(cx.raw_cx(), &error);
12396 return false;
12397
12398 }
12399 _ => {
12400 return false;
12401
12402 },
12403 }
12404 ;
12405 let result: () = this.Clear(arg0);
12406
12407 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12408 return true;
12409 })());
12410 result
12411}
12412
12413
12414static clear_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12415
12416pub(crate) fn init_clear_methodinfo<D: DomTypes>() {
12417 clear_methodinfo.set(JSJitInfo {
12418 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12419 method: Some(clear::<D>)
12420 },
12421 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12422 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12423 },
12424 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12425 _bitfield_align_1: [],
12426 _bitfield_1: __BindgenBitfieldUnit::new(
12427 new_jsjitinfo_bitfield_1!(
12428 JSJitInfo_OpType::Method as u8,
12429 JSJitInfo_AliasSet::AliasEverything as u8,
12430 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12431 false,
12432 false,
12433 false,
12434 false,
12435 false,
12436 false,
12437 0,
12438 ).to_ne_bytes()
12439 ),
12440});
12441}
12442unsafe extern "C" fn clearColor<D: DomTypes>
12443(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12444 let mut result = false;
12445 wrap_panic(&mut || result = (|| {
12446 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12447 let this = &*(this as *const D::WebGL2RenderingContext);
12448 let args = &*args;
12449 let argc = args.argc_;
12450
12451 if argc < 4 {
12452 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clearColor\".");
12453 return false;
12454 }
12455 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12456 Ok(ConversionResult::Success(value)) => value,
12457 Ok(ConversionResult::Failure(error)) => {
12458 throw_type_error(cx.raw_cx(), &error);
12459 return false;
12460
12461 }
12462 _ => {
12463 return false;
12464
12465 },
12466 }
12467 ;
12468 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
12469 Ok(ConversionResult::Success(value)) => value,
12470 Ok(ConversionResult::Failure(error)) => {
12471 throw_type_error(cx.raw_cx(), &error);
12472 return false;
12473
12474 }
12475 _ => {
12476 return false;
12477
12478 },
12479 }
12480 ;
12481 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
12482 Ok(ConversionResult::Success(value)) => value,
12483 Ok(ConversionResult::Failure(error)) => {
12484 throw_type_error(cx.raw_cx(), &error);
12485 return false;
12486
12487 }
12488 _ => {
12489 return false;
12490
12491 },
12492 }
12493 ;
12494 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
12495 Ok(ConversionResult::Success(value)) => value,
12496 Ok(ConversionResult::Failure(error)) => {
12497 throw_type_error(cx.raw_cx(), &error);
12498 return false;
12499
12500 }
12501 _ => {
12502 return false;
12503
12504 },
12505 }
12506 ;
12507 let result: () = this.ClearColor(arg0, arg1, arg2, arg3);
12508
12509 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12510 return true;
12511 })());
12512 result
12513}
12514
12515
12516static clearColor_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12517
12518pub(crate) fn init_clearColor_methodinfo<D: DomTypes>() {
12519 clearColor_methodinfo.set(JSJitInfo {
12520 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12521 method: Some(clearColor::<D>)
12522 },
12523 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12524 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12525 },
12526 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12527 _bitfield_align_1: [],
12528 _bitfield_1: __BindgenBitfieldUnit::new(
12529 new_jsjitinfo_bitfield_1!(
12530 JSJitInfo_OpType::Method as u8,
12531 JSJitInfo_AliasSet::AliasEverything as u8,
12532 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12533 false,
12534 false,
12535 false,
12536 false,
12537 false,
12538 false,
12539 0,
12540 ).to_ne_bytes()
12541 ),
12542});
12543}
12544unsafe extern "C" fn clearDepth<D: DomTypes>
12545(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12546 let mut result = false;
12547 wrap_panic(&mut || result = (|| {
12548 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12549 let this = &*(this as *const D::WebGL2RenderingContext);
12550 let args = &*args;
12551 let argc = args.argc_;
12552
12553 if argc < 1 {
12554 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clearDepth\".");
12555 return false;
12556 }
12557 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12558 Ok(ConversionResult::Success(value)) => value,
12559 Ok(ConversionResult::Failure(error)) => {
12560 throw_type_error(cx.raw_cx(), &error);
12561 return false;
12562
12563 }
12564 _ => {
12565 return false;
12566
12567 },
12568 }
12569 ;
12570 let result: () = this.ClearDepth(arg0);
12571
12572 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12573 return true;
12574 })());
12575 result
12576}
12577
12578
12579static clearDepth_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12580
12581pub(crate) fn init_clearDepth_methodinfo<D: DomTypes>() {
12582 clearDepth_methodinfo.set(JSJitInfo {
12583 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12584 method: Some(clearDepth::<D>)
12585 },
12586 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12587 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12588 },
12589 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12590 _bitfield_align_1: [],
12591 _bitfield_1: __BindgenBitfieldUnit::new(
12592 new_jsjitinfo_bitfield_1!(
12593 JSJitInfo_OpType::Method as u8,
12594 JSJitInfo_AliasSet::AliasEverything as u8,
12595 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12596 false,
12597 false,
12598 false,
12599 false,
12600 false,
12601 false,
12602 0,
12603 ).to_ne_bytes()
12604 ),
12605});
12606}
12607unsafe extern "C" fn clearStencil<D: DomTypes>
12608(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12609 let mut result = false;
12610 wrap_panic(&mut || result = (|| {
12611 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12612 let this = &*(this as *const D::WebGL2RenderingContext);
12613 let args = &*args;
12614 let argc = args.argc_;
12615
12616 if argc < 1 {
12617 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.clearStencil\".");
12618 return false;
12619 }
12620 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
12621 Ok(ConversionResult::Success(value)) => value,
12622 Ok(ConversionResult::Failure(error)) => {
12623 throw_type_error(cx.raw_cx(), &error);
12624 return false;
12625
12626 }
12627 _ => {
12628 return false;
12629
12630 },
12631 }
12632 ;
12633 let result: () = this.ClearStencil(arg0);
12634
12635 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12636 return true;
12637 })());
12638 result
12639}
12640
12641
12642static clearStencil_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12643
12644pub(crate) fn init_clearStencil_methodinfo<D: DomTypes>() {
12645 clearStencil_methodinfo.set(JSJitInfo {
12646 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12647 method: Some(clearStencil::<D>)
12648 },
12649 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12650 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12651 },
12652 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12653 _bitfield_align_1: [],
12654 _bitfield_1: __BindgenBitfieldUnit::new(
12655 new_jsjitinfo_bitfield_1!(
12656 JSJitInfo_OpType::Method as u8,
12657 JSJitInfo_AliasSet::AliasEverything as u8,
12658 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12659 false,
12660 false,
12661 false,
12662 false,
12663 false,
12664 false,
12665 0,
12666 ).to_ne_bytes()
12667 ),
12668});
12669}
12670unsafe extern "C" fn colorMask<D: DomTypes>
12671(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12672 let mut result = false;
12673 wrap_panic(&mut || result = (|| {
12674 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12675 let this = &*(this as *const D::WebGL2RenderingContext);
12676 let args = &*args;
12677 let argc = args.argc_;
12678
12679 if argc < 4 {
12680 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.colorMask\".");
12681 return false;
12682 }
12683 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12684 Ok(ConversionResult::Success(value)) => value,
12685 Ok(ConversionResult::Failure(error)) => {
12686 throw_type_error(cx.raw_cx(), &error);
12687 return false;
12688
12689 }
12690 _ => {
12691 return false;
12692
12693 },
12694 }
12695 ;
12696 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
12697 Ok(ConversionResult::Success(value)) => value,
12698 Ok(ConversionResult::Failure(error)) => {
12699 throw_type_error(cx.raw_cx(), &error);
12700 return false;
12701
12702 }
12703 _ => {
12704 return false;
12705
12706 },
12707 }
12708 ;
12709 let arg2: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
12710 Ok(ConversionResult::Success(value)) => value,
12711 Ok(ConversionResult::Failure(error)) => {
12712 throw_type_error(cx.raw_cx(), &error);
12713 return false;
12714
12715 }
12716 _ => {
12717 return false;
12718
12719 },
12720 }
12721 ;
12722 let arg3: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
12723 Ok(ConversionResult::Success(value)) => value,
12724 Ok(ConversionResult::Failure(error)) => {
12725 throw_type_error(cx.raw_cx(), &error);
12726 return false;
12727
12728 }
12729 _ => {
12730 return false;
12731
12732 },
12733 }
12734 ;
12735 let result: () = this.ColorMask(arg0, arg1, arg2, arg3);
12736
12737 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12738 return true;
12739 })());
12740 result
12741}
12742
12743
12744static colorMask_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12745
12746pub(crate) fn init_colorMask_methodinfo<D: DomTypes>() {
12747 colorMask_methodinfo.set(JSJitInfo {
12748 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12749 method: Some(colorMask::<D>)
12750 },
12751 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12752 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12753 },
12754 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12755 _bitfield_align_1: [],
12756 _bitfield_1: __BindgenBitfieldUnit::new(
12757 new_jsjitinfo_bitfield_1!(
12758 JSJitInfo_OpType::Method as u8,
12759 JSJitInfo_AliasSet::AliasEverything as u8,
12760 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12761 false,
12762 false,
12763 false,
12764 false,
12765 false,
12766 false,
12767 0,
12768 ).to_ne_bytes()
12769 ),
12770});
12771}
12772unsafe extern "C" fn compileShader<D: DomTypes>
12773(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12774 let mut result = false;
12775 wrap_panic(&mut || result = (|| {
12776 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12777 let this = &*(this as *const D::WebGL2RenderingContext);
12778 let args = &*args;
12779 let argc = args.argc_;
12780
12781 if argc < 1 {
12782 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.compileShader\".");
12783 return false;
12784 }
12785 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12786 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
12787 Ok(val) => val,
12788 Err(()) => {
12789 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
12790 return false;
12791
12792 }
12793 }
12794
12795 } else {
12796 throw_type_error(cx.raw_cx(), "Value is not an object.");
12797 return false;
12798
12799 };
12800 let result: () = this.CompileShader(&arg0);
12801
12802 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12803 return true;
12804 })());
12805 result
12806}
12807
12808
12809static compileShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12810
12811pub(crate) fn init_compileShader_methodinfo<D: DomTypes>() {
12812 compileShader_methodinfo.set(JSJitInfo {
12813 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12814 method: Some(compileShader::<D>)
12815 },
12816 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12817 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12818 },
12819 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12820 _bitfield_align_1: [],
12821 _bitfield_1: __BindgenBitfieldUnit::new(
12822 new_jsjitinfo_bitfield_1!(
12823 JSJitInfo_OpType::Method as u8,
12824 JSJitInfo_AliasSet::AliasEverything as u8,
12825 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12826 false,
12827 false,
12828 false,
12829 false,
12830 false,
12831 false,
12832 0,
12833 ).to_ne_bytes()
12834 ),
12835});
12836}
12837unsafe extern "C" fn copyTexImage2D<D: DomTypes>
12838(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12839 let mut result = false;
12840 wrap_panic(&mut || result = (|| {
12841 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12842 let this = &*(this as *const D::WebGL2RenderingContext);
12843 let args = &*args;
12844 let argc = args.argc_;
12845
12846 if argc < 8 {
12847 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.copyTexImage2D\".");
12848 return false;
12849 }
12850 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
12851 Ok(ConversionResult::Success(value)) => value,
12852 Ok(ConversionResult::Failure(error)) => {
12853 throw_type_error(cx.raw_cx(), &error);
12854 return false;
12855
12856 }
12857 _ => {
12858 return false;
12859
12860 },
12861 }
12862 ;
12863 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
12864 Ok(ConversionResult::Success(value)) => value,
12865 Ok(ConversionResult::Failure(error)) => {
12866 throw_type_error(cx.raw_cx(), &error);
12867 return false;
12868
12869 }
12870 _ => {
12871 return false;
12872
12873 },
12874 }
12875 ;
12876 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
12877 Ok(ConversionResult::Success(value)) => value,
12878 Ok(ConversionResult::Failure(error)) => {
12879 throw_type_error(cx.raw_cx(), &error);
12880 return false;
12881
12882 }
12883 _ => {
12884 return false;
12885
12886 },
12887 }
12888 ;
12889 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
12890 Ok(ConversionResult::Success(value)) => value,
12891 Ok(ConversionResult::Failure(error)) => {
12892 throw_type_error(cx.raw_cx(), &error);
12893 return false;
12894
12895 }
12896 _ => {
12897 return false;
12898
12899 },
12900 }
12901 ;
12902 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
12903 Ok(ConversionResult::Success(value)) => value,
12904 Ok(ConversionResult::Failure(error)) => {
12905 throw_type_error(cx.raw_cx(), &error);
12906 return false;
12907
12908 }
12909 _ => {
12910 return false;
12911
12912 },
12913 }
12914 ;
12915 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
12916 Ok(ConversionResult::Success(value)) => value,
12917 Ok(ConversionResult::Failure(error)) => {
12918 throw_type_error(cx.raw_cx(), &error);
12919 return false;
12920
12921 }
12922 _ => {
12923 return false;
12924
12925 },
12926 }
12927 ;
12928 let arg6: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
12929 Ok(ConversionResult::Success(value)) => value,
12930 Ok(ConversionResult::Failure(error)) => {
12931 throw_type_error(cx.raw_cx(), &error);
12932 return false;
12933
12934 }
12935 _ => {
12936 return false;
12937
12938 },
12939 }
12940 ;
12941 let arg7: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
12942 Ok(ConversionResult::Success(value)) => value,
12943 Ok(ConversionResult::Failure(error)) => {
12944 throw_type_error(cx.raw_cx(), &error);
12945 return false;
12946
12947 }
12948 _ => {
12949 return false;
12950
12951 },
12952 }
12953 ;
12954 let result: () = this.CopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
12955
12956 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12957 return true;
12958 })());
12959 result
12960}
12961
12962
12963static copyTexImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12964
12965pub(crate) fn init_copyTexImage2D_methodinfo<D: DomTypes>() {
12966 copyTexImage2D_methodinfo.set(JSJitInfo {
12967 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12968 method: Some(copyTexImage2D::<D>)
12969 },
12970 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12971 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
12972 },
12973 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12974 _bitfield_align_1: [],
12975 _bitfield_1: __BindgenBitfieldUnit::new(
12976 new_jsjitinfo_bitfield_1!(
12977 JSJitInfo_OpType::Method as u8,
12978 JSJitInfo_AliasSet::AliasEverything as u8,
12979 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12980 false,
12981 false,
12982 false,
12983 false,
12984 false,
12985 false,
12986 0,
12987 ).to_ne_bytes()
12988 ),
12989});
12990}
12991unsafe extern "C" fn copyTexSubImage2D<D: DomTypes>
12992(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12993 let mut result = false;
12994 wrap_panic(&mut || result = (|| {
12995 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12996 let this = &*(this as *const D::WebGL2RenderingContext);
12997 let args = &*args;
12998 let argc = args.argc_;
12999
13000 if argc < 8 {
13001 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.copyTexSubImage2D\".");
13002 return false;
13003 }
13004 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
13005 Ok(ConversionResult::Success(value)) => value,
13006 Ok(ConversionResult::Failure(error)) => {
13007 throw_type_error(cx.raw_cx(), &error);
13008 return false;
13009
13010 }
13011 _ => {
13012 return false;
13013
13014 },
13015 }
13016 ;
13017 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
13018 Ok(ConversionResult::Success(value)) => value,
13019 Ok(ConversionResult::Failure(error)) => {
13020 throw_type_error(cx.raw_cx(), &error);
13021 return false;
13022
13023 }
13024 _ => {
13025 return false;
13026
13027 },
13028 }
13029 ;
13030 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
13031 Ok(ConversionResult::Success(value)) => value,
13032 Ok(ConversionResult::Failure(error)) => {
13033 throw_type_error(cx.raw_cx(), &error);
13034 return false;
13035
13036 }
13037 _ => {
13038 return false;
13039
13040 },
13041 }
13042 ;
13043 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
13044 Ok(ConversionResult::Success(value)) => value,
13045 Ok(ConversionResult::Failure(error)) => {
13046 throw_type_error(cx.raw_cx(), &error);
13047 return false;
13048
13049 }
13050 _ => {
13051 return false;
13052
13053 },
13054 }
13055 ;
13056 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
13057 Ok(ConversionResult::Success(value)) => value,
13058 Ok(ConversionResult::Failure(error)) => {
13059 throw_type_error(cx.raw_cx(), &error);
13060 return false;
13061
13062 }
13063 _ => {
13064 return false;
13065
13066 },
13067 }
13068 ;
13069 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
13070 Ok(ConversionResult::Success(value)) => value,
13071 Ok(ConversionResult::Failure(error)) => {
13072 throw_type_error(cx.raw_cx(), &error);
13073 return false;
13074
13075 }
13076 _ => {
13077 return false;
13078
13079 },
13080 }
13081 ;
13082 let arg6: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
13083 Ok(ConversionResult::Success(value)) => value,
13084 Ok(ConversionResult::Failure(error)) => {
13085 throw_type_error(cx.raw_cx(), &error);
13086 return false;
13087
13088 }
13089 _ => {
13090 return false;
13091
13092 },
13093 }
13094 ;
13095 let arg7: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
13096 Ok(ConversionResult::Success(value)) => value,
13097 Ok(ConversionResult::Failure(error)) => {
13098 throw_type_error(cx.raw_cx(), &error);
13099 return false;
13100
13101 }
13102 _ => {
13103 return false;
13104
13105 },
13106 }
13107 ;
13108 let result: () = this.CopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
13109
13110 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13111 return true;
13112 })());
13113 result
13114}
13115
13116
13117static copyTexSubImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13118
13119pub(crate) fn init_copyTexSubImage2D_methodinfo<D: DomTypes>() {
13120 copyTexSubImage2D_methodinfo.set(JSJitInfo {
13121 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13122 method: Some(copyTexSubImage2D::<D>)
13123 },
13124 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13125 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13126 },
13127 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13128 _bitfield_align_1: [],
13129 _bitfield_1: __BindgenBitfieldUnit::new(
13130 new_jsjitinfo_bitfield_1!(
13131 JSJitInfo_OpType::Method as u8,
13132 JSJitInfo_AliasSet::AliasEverything as u8,
13133 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13134 false,
13135 false,
13136 false,
13137 false,
13138 false,
13139 false,
13140 0,
13141 ).to_ne_bytes()
13142 ),
13143});
13144}
13145unsafe extern "C" fn createBuffer<D: DomTypes>
13146(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13147 let mut result = false;
13148 wrap_panic(&mut || result = (|| {
13149 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13150 let this = &*(this as *const D::WebGL2RenderingContext);
13151 let args = &*args;
13152 let argc = args.argc_;
13153 let result: Option<DomRoot<D::WebGLBuffer>> = this.CreateBuffer();
13154
13155 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13156 return true;
13157 })());
13158 result
13159}
13160
13161
13162static createBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13163
13164pub(crate) fn init_createBuffer_methodinfo<D: DomTypes>() {
13165 createBuffer_methodinfo.set(JSJitInfo {
13166 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13167 method: Some(createBuffer::<D>)
13168 },
13169 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13170 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13171 },
13172 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13173 _bitfield_align_1: [],
13174 _bitfield_1: __BindgenBitfieldUnit::new(
13175 new_jsjitinfo_bitfield_1!(
13176 JSJitInfo_OpType::Method as u8,
13177 JSJitInfo_AliasSet::AliasEverything as u8,
13178 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13179 true,
13180 false,
13181 false,
13182 false,
13183 false,
13184 false,
13185 0,
13186 ).to_ne_bytes()
13187 ),
13188});
13189}
13190unsafe extern "C" fn createFramebuffer<D: DomTypes>
13191(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13192 let mut result = false;
13193 wrap_panic(&mut || result = (|| {
13194 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13195 let this = &*(this as *const D::WebGL2RenderingContext);
13196 let args = &*args;
13197 let argc = args.argc_;
13198 let result: Option<DomRoot<D::WebGLFramebuffer>> = this.CreateFramebuffer();
13199
13200 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13201 return true;
13202 })());
13203 result
13204}
13205
13206
13207static createFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13208
13209pub(crate) fn init_createFramebuffer_methodinfo<D: DomTypes>() {
13210 createFramebuffer_methodinfo.set(JSJitInfo {
13211 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13212 method: Some(createFramebuffer::<D>)
13213 },
13214 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13215 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13216 },
13217 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13218 _bitfield_align_1: [],
13219 _bitfield_1: __BindgenBitfieldUnit::new(
13220 new_jsjitinfo_bitfield_1!(
13221 JSJitInfo_OpType::Method as u8,
13222 JSJitInfo_AliasSet::AliasEverything as u8,
13223 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13224 true,
13225 false,
13226 false,
13227 false,
13228 false,
13229 false,
13230 0,
13231 ).to_ne_bytes()
13232 ),
13233});
13234}
13235unsafe extern "C" fn createProgram<D: DomTypes>
13236(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13237 let mut result = false;
13238 wrap_panic(&mut || result = (|| {
13239 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13240 let this = &*(this as *const D::WebGL2RenderingContext);
13241 let args = &*args;
13242 let argc = args.argc_;
13243 let result: Option<DomRoot<D::WebGLProgram>> = this.CreateProgram();
13244
13245 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13246 return true;
13247 })());
13248 result
13249}
13250
13251
13252static createProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13253
13254pub(crate) fn init_createProgram_methodinfo<D: DomTypes>() {
13255 createProgram_methodinfo.set(JSJitInfo {
13256 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13257 method: Some(createProgram::<D>)
13258 },
13259 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13260 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13261 },
13262 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13263 _bitfield_align_1: [],
13264 _bitfield_1: __BindgenBitfieldUnit::new(
13265 new_jsjitinfo_bitfield_1!(
13266 JSJitInfo_OpType::Method as u8,
13267 JSJitInfo_AliasSet::AliasEverything as u8,
13268 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13269 true,
13270 false,
13271 false,
13272 false,
13273 false,
13274 false,
13275 0,
13276 ).to_ne_bytes()
13277 ),
13278});
13279}
13280unsafe extern "C" fn createRenderbuffer<D: DomTypes>
13281(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13282 let mut result = false;
13283 wrap_panic(&mut || result = (|| {
13284 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13285 let this = &*(this as *const D::WebGL2RenderingContext);
13286 let args = &*args;
13287 let argc = args.argc_;
13288 let result: Option<DomRoot<D::WebGLRenderbuffer>> = this.CreateRenderbuffer();
13289
13290 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13291 return true;
13292 })());
13293 result
13294}
13295
13296
13297static createRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13298
13299pub(crate) fn init_createRenderbuffer_methodinfo<D: DomTypes>() {
13300 createRenderbuffer_methodinfo.set(JSJitInfo {
13301 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13302 method: Some(createRenderbuffer::<D>)
13303 },
13304 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13305 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13306 },
13307 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13308 _bitfield_align_1: [],
13309 _bitfield_1: __BindgenBitfieldUnit::new(
13310 new_jsjitinfo_bitfield_1!(
13311 JSJitInfo_OpType::Method as u8,
13312 JSJitInfo_AliasSet::AliasEverything as u8,
13313 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13314 true,
13315 false,
13316 false,
13317 false,
13318 false,
13319 false,
13320 0,
13321 ).to_ne_bytes()
13322 ),
13323});
13324}
13325unsafe extern "C" fn createShader<D: DomTypes>
13326(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13327 let mut result = false;
13328 wrap_panic(&mut || result = (|| {
13329 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13330 let this = &*(this as *const D::WebGL2RenderingContext);
13331 let args = &*args;
13332 let argc = args.argc_;
13333
13334 if argc < 1 {
13335 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.createShader\".");
13336 return false;
13337 }
13338 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
13339 Ok(ConversionResult::Success(value)) => value,
13340 Ok(ConversionResult::Failure(error)) => {
13341 throw_type_error(cx.raw_cx(), &error);
13342 return false;
13343
13344 }
13345 _ => {
13346 return false;
13347
13348 },
13349 }
13350 ;
13351 let result: Option<DomRoot<D::WebGLShader>> = this.CreateShader(arg0);
13352
13353 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13354 return true;
13355 })());
13356 result
13357}
13358
13359
13360static createShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13361
13362pub(crate) fn init_createShader_methodinfo<D: DomTypes>() {
13363 createShader_methodinfo.set(JSJitInfo {
13364 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13365 method: Some(createShader::<D>)
13366 },
13367 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13368 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13369 },
13370 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13371 _bitfield_align_1: [],
13372 _bitfield_1: __BindgenBitfieldUnit::new(
13373 new_jsjitinfo_bitfield_1!(
13374 JSJitInfo_OpType::Method as u8,
13375 JSJitInfo_AliasSet::AliasEverything as u8,
13376 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13377 false,
13378 false,
13379 false,
13380 false,
13381 false,
13382 false,
13383 0,
13384 ).to_ne_bytes()
13385 ),
13386});
13387}
13388unsafe extern "C" fn createTexture<D: DomTypes>
13389(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13390 let mut result = false;
13391 wrap_panic(&mut || result = (|| {
13392 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13393 let this = &*(this as *const D::WebGL2RenderingContext);
13394 let args = &*args;
13395 let argc = args.argc_;
13396 let result: Option<DomRoot<D::WebGLTexture>> = this.CreateTexture();
13397
13398 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13399 return true;
13400 })());
13401 result
13402}
13403
13404
13405static createTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13406
13407pub(crate) fn init_createTexture_methodinfo<D: DomTypes>() {
13408 createTexture_methodinfo.set(JSJitInfo {
13409 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13410 method: Some(createTexture::<D>)
13411 },
13412 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13413 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13414 },
13415 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13416 _bitfield_align_1: [],
13417 _bitfield_1: __BindgenBitfieldUnit::new(
13418 new_jsjitinfo_bitfield_1!(
13419 JSJitInfo_OpType::Method as u8,
13420 JSJitInfo_AliasSet::AliasEverything as u8,
13421 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
13422 true,
13423 false,
13424 false,
13425 false,
13426 false,
13427 false,
13428 0,
13429 ).to_ne_bytes()
13430 ),
13431});
13432}
13433unsafe extern "C" fn cullFace<D: DomTypes>
13434(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13435 let mut result = false;
13436 wrap_panic(&mut || result = (|| {
13437 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13438 let this = &*(this as *const D::WebGL2RenderingContext);
13439 let args = &*args;
13440 let argc = args.argc_;
13441
13442 if argc < 1 {
13443 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.cullFace\".");
13444 return false;
13445 }
13446 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
13447 Ok(ConversionResult::Success(value)) => value,
13448 Ok(ConversionResult::Failure(error)) => {
13449 throw_type_error(cx.raw_cx(), &error);
13450 return false;
13451
13452 }
13453 _ => {
13454 return false;
13455
13456 },
13457 }
13458 ;
13459 let result: () = this.CullFace(arg0);
13460
13461 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13462 return true;
13463 })());
13464 result
13465}
13466
13467
13468static cullFace_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13469
13470pub(crate) fn init_cullFace_methodinfo<D: DomTypes>() {
13471 cullFace_methodinfo.set(JSJitInfo {
13472 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13473 method: Some(cullFace::<D>)
13474 },
13475 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13476 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13477 },
13478 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13479 _bitfield_align_1: [],
13480 _bitfield_1: __BindgenBitfieldUnit::new(
13481 new_jsjitinfo_bitfield_1!(
13482 JSJitInfo_OpType::Method as u8,
13483 JSJitInfo_AliasSet::AliasEverything as u8,
13484 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13485 false,
13486 false,
13487 false,
13488 false,
13489 false,
13490 false,
13491 0,
13492 ).to_ne_bytes()
13493 ),
13494});
13495}
13496unsafe extern "C" fn deleteBuffer<D: DomTypes>
13497(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13498 let mut result = false;
13499 wrap_panic(&mut || result = (|| {
13500 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13501 let this = &*(this as *const D::WebGL2RenderingContext);
13502 let args = &*args;
13503 let argc = args.argc_;
13504
13505 if argc < 1 {
13506 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteBuffer\".");
13507 return false;
13508 }
13509 let arg0: Option<DomRoot<D::WebGLBuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13510 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
13511 Ok(val) => val,
13512 Err(()) => {
13513 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLBuffer.");
13514 return false;
13515
13516 }
13517 }
13518 )
13519 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
13520 None
13521 } else {
13522 throw_type_error(cx.raw_cx(), "Value is not an object.");
13523 return false;
13524
13525 };
13526 let result: () = this.DeleteBuffer(arg0.as_deref());
13527
13528 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13529 return true;
13530 })());
13531 result
13532}
13533
13534
13535static deleteBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13536
13537pub(crate) fn init_deleteBuffer_methodinfo<D: DomTypes>() {
13538 deleteBuffer_methodinfo.set(JSJitInfo {
13539 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13540 method: Some(deleteBuffer::<D>)
13541 },
13542 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13543 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13544 },
13545 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13546 _bitfield_align_1: [],
13547 _bitfield_1: __BindgenBitfieldUnit::new(
13548 new_jsjitinfo_bitfield_1!(
13549 JSJitInfo_OpType::Method as u8,
13550 JSJitInfo_AliasSet::AliasEverything as u8,
13551 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13552 false,
13553 false,
13554 false,
13555 false,
13556 false,
13557 false,
13558 0,
13559 ).to_ne_bytes()
13560 ),
13561});
13562}
13563unsafe extern "C" fn deleteFramebuffer<D: DomTypes>
13564(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13565 let mut result = false;
13566 wrap_panic(&mut || result = (|| {
13567 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13568 let this = &*(this as *const D::WebGL2RenderingContext);
13569 let args = &*args;
13570 let argc = args.argc_;
13571
13572 if argc < 1 {
13573 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteFramebuffer\".");
13574 return false;
13575 }
13576 let arg0: Option<DomRoot<D::WebGLFramebuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13577 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
13578 Ok(val) => val,
13579 Err(()) => {
13580 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLFramebuffer.");
13581 return false;
13582
13583 }
13584 }
13585 )
13586 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
13587 None
13588 } else {
13589 throw_type_error(cx.raw_cx(), "Value is not an object.");
13590 return false;
13591
13592 };
13593 let result: () = this.DeleteFramebuffer(arg0.as_deref());
13594
13595 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13596 return true;
13597 })());
13598 result
13599}
13600
13601
13602static deleteFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13603
13604pub(crate) fn init_deleteFramebuffer_methodinfo<D: DomTypes>() {
13605 deleteFramebuffer_methodinfo.set(JSJitInfo {
13606 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13607 method: Some(deleteFramebuffer::<D>)
13608 },
13609 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13610 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13611 },
13612 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13613 _bitfield_align_1: [],
13614 _bitfield_1: __BindgenBitfieldUnit::new(
13615 new_jsjitinfo_bitfield_1!(
13616 JSJitInfo_OpType::Method as u8,
13617 JSJitInfo_AliasSet::AliasEverything as u8,
13618 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13619 false,
13620 false,
13621 false,
13622 false,
13623 false,
13624 false,
13625 0,
13626 ).to_ne_bytes()
13627 ),
13628});
13629}
13630unsafe extern "C" fn deleteProgram<D: DomTypes>
13631(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13632 let mut result = false;
13633 wrap_panic(&mut || result = (|| {
13634 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13635 let this = &*(this as *const D::WebGL2RenderingContext);
13636 let args = &*args;
13637 let argc = args.argc_;
13638
13639 if argc < 1 {
13640 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteProgram\".");
13641 return false;
13642 }
13643 let arg0: Option<DomRoot<D::WebGLProgram>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13644 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
13645 Ok(val) => val,
13646 Err(()) => {
13647 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
13648 return false;
13649
13650 }
13651 }
13652 )
13653 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
13654 None
13655 } else {
13656 throw_type_error(cx.raw_cx(), "Value is not an object.");
13657 return false;
13658
13659 };
13660 let result: () = this.DeleteProgram(arg0.as_deref());
13661
13662 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13663 return true;
13664 })());
13665 result
13666}
13667
13668
13669static deleteProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13670
13671pub(crate) fn init_deleteProgram_methodinfo<D: DomTypes>() {
13672 deleteProgram_methodinfo.set(JSJitInfo {
13673 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13674 method: Some(deleteProgram::<D>)
13675 },
13676 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13677 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13678 },
13679 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13680 _bitfield_align_1: [],
13681 _bitfield_1: __BindgenBitfieldUnit::new(
13682 new_jsjitinfo_bitfield_1!(
13683 JSJitInfo_OpType::Method as u8,
13684 JSJitInfo_AliasSet::AliasEverything as u8,
13685 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13686 false,
13687 false,
13688 false,
13689 false,
13690 false,
13691 false,
13692 0,
13693 ).to_ne_bytes()
13694 ),
13695});
13696}
13697unsafe extern "C" fn deleteRenderbuffer<D: DomTypes>
13698(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13699 let mut result = false;
13700 wrap_panic(&mut || result = (|| {
13701 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13702 let this = &*(this as *const D::WebGL2RenderingContext);
13703 let args = &*args;
13704 let argc = args.argc_;
13705
13706 if argc < 1 {
13707 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteRenderbuffer\".");
13708 return false;
13709 }
13710 let arg0: Option<DomRoot<D::WebGLRenderbuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13711 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
13712 Ok(val) => val,
13713 Err(()) => {
13714 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLRenderbuffer.");
13715 return false;
13716
13717 }
13718 }
13719 )
13720 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
13721 None
13722 } else {
13723 throw_type_error(cx.raw_cx(), "Value is not an object.");
13724 return false;
13725
13726 };
13727 let result: () = this.DeleteRenderbuffer(arg0.as_deref());
13728
13729 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13730 return true;
13731 })());
13732 result
13733}
13734
13735
13736static deleteRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13737
13738pub(crate) fn init_deleteRenderbuffer_methodinfo<D: DomTypes>() {
13739 deleteRenderbuffer_methodinfo.set(JSJitInfo {
13740 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13741 method: Some(deleteRenderbuffer::<D>)
13742 },
13743 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13744 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13745 },
13746 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13747 _bitfield_align_1: [],
13748 _bitfield_1: __BindgenBitfieldUnit::new(
13749 new_jsjitinfo_bitfield_1!(
13750 JSJitInfo_OpType::Method as u8,
13751 JSJitInfo_AliasSet::AliasEverything as u8,
13752 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13753 false,
13754 false,
13755 false,
13756 false,
13757 false,
13758 false,
13759 0,
13760 ).to_ne_bytes()
13761 ),
13762});
13763}
13764unsafe extern "C" fn deleteShader<D: DomTypes>
13765(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13766 let mut result = false;
13767 wrap_panic(&mut || result = (|| {
13768 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13769 let this = &*(this as *const D::WebGL2RenderingContext);
13770 let args = &*args;
13771 let argc = args.argc_;
13772
13773 if argc < 1 {
13774 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteShader\".");
13775 return false;
13776 }
13777 let arg0: Option<DomRoot<D::WebGLShader>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13778 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
13779 Ok(val) => val,
13780 Err(()) => {
13781 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
13782 return false;
13783
13784 }
13785 }
13786 )
13787 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
13788 None
13789 } else {
13790 throw_type_error(cx.raw_cx(), "Value is not an object.");
13791 return false;
13792
13793 };
13794 let result: () = this.DeleteShader(arg0.as_deref());
13795
13796 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13797 return true;
13798 })());
13799 result
13800}
13801
13802
13803static deleteShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13804
13805pub(crate) fn init_deleteShader_methodinfo<D: DomTypes>() {
13806 deleteShader_methodinfo.set(JSJitInfo {
13807 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13808 method: Some(deleteShader::<D>)
13809 },
13810 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13811 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13812 },
13813 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13814 _bitfield_align_1: [],
13815 _bitfield_1: __BindgenBitfieldUnit::new(
13816 new_jsjitinfo_bitfield_1!(
13817 JSJitInfo_OpType::Method as u8,
13818 JSJitInfo_AliasSet::AliasEverything as u8,
13819 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13820 false,
13821 false,
13822 false,
13823 false,
13824 false,
13825 false,
13826 0,
13827 ).to_ne_bytes()
13828 ),
13829});
13830}
13831unsafe extern "C" fn deleteTexture<D: DomTypes>
13832(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13833 let mut result = false;
13834 wrap_panic(&mut || result = (|| {
13835 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13836 let this = &*(this as *const D::WebGL2RenderingContext);
13837 let args = &*args;
13838 let argc = args.argc_;
13839
13840 if argc < 1 {
13841 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.deleteTexture\".");
13842 return false;
13843 }
13844 let arg0: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13845 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
13846 Ok(val) => val,
13847 Err(()) => {
13848 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
13849 return false;
13850
13851 }
13852 }
13853 )
13854 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
13855 None
13856 } else {
13857 throw_type_error(cx.raw_cx(), "Value is not an object.");
13858 return false;
13859
13860 };
13861 let result: () = this.DeleteTexture(arg0.as_deref());
13862
13863 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13864 return true;
13865 })());
13866 result
13867}
13868
13869
13870static deleteTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13871
13872pub(crate) fn init_deleteTexture_methodinfo<D: DomTypes>() {
13873 deleteTexture_methodinfo.set(JSJitInfo {
13874 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13875 method: Some(deleteTexture::<D>)
13876 },
13877 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13878 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13879 },
13880 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13881 _bitfield_align_1: [],
13882 _bitfield_1: __BindgenBitfieldUnit::new(
13883 new_jsjitinfo_bitfield_1!(
13884 JSJitInfo_OpType::Method as u8,
13885 JSJitInfo_AliasSet::AliasEverything as u8,
13886 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13887 false,
13888 false,
13889 false,
13890 false,
13891 false,
13892 false,
13893 0,
13894 ).to_ne_bytes()
13895 ),
13896});
13897}
13898unsafe extern "C" fn depthFunc<D: DomTypes>
13899(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13900 let mut result = false;
13901 wrap_panic(&mut || result = (|| {
13902 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13903 let this = &*(this as *const D::WebGL2RenderingContext);
13904 let args = &*args;
13905 let argc = args.argc_;
13906
13907 if argc < 1 {
13908 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.depthFunc\".");
13909 return false;
13910 }
13911 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
13912 Ok(ConversionResult::Success(value)) => value,
13913 Ok(ConversionResult::Failure(error)) => {
13914 throw_type_error(cx.raw_cx(), &error);
13915 return false;
13916
13917 }
13918 _ => {
13919 return false;
13920
13921 },
13922 }
13923 ;
13924 let result: () = this.DepthFunc(arg0);
13925
13926 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13927 return true;
13928 })());
13929 result
13930}
13931
13932
13933static depthFunc_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13934
13935pub(crate) fn init_depthFunc_methodinfo<D: DomTypes>() {
13936 depthFunc_methodinfo.set(JSJitInfo {
13937 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13938 method: Some(depthFunc::<D>)
13939 },
13940 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13941 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
13942 },
13943 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13944 _bitfield_align_1: [],
13945 _bitfield_1: __BindgenBitfieldUnit::new(
13946 new_jsjitinfo_bitfield_1!(
13947 JSJitInfo_OpType::Method as u8,
13948 JSJitInfo_AliasSet::AliasEverything as u8,
13949 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13950 false,
13951 false,
13952 false,
13953 false,
13954 false,
13955 false,
13956 0,
13957 ).to_ne_bytes()
13958 ),
13959});
13960}
13961unsafe extern "C" fn depthMask<D: DomTypes>
13962(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13963 let mut result = false;
13964 wrap_panic(&mut || result = (|| {
13965 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13966 let this = &*(this as *const D::WebGL2RenderingContext);
13967 let args = &*args;
13968 let argc = args.argc_;
13969
13970 if argc < 1 {
13971 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.depthMask\".");
13972 return false;
13973 }
13974 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13975 Ok(ConversionResult::Success(value)) => value,
13976 Ok(ConversionResult::Failure(error)) => {
13977 throw_type_error(cx.raw_cx(), &error);
13978 return false;
13979
13980 }
13981 _ => {
13982 return false;
13983
13984 },
13985 }
13986 ;
13987 let result: () = this.DepthMask(arg0);
13988
13989 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13990 return true;
13991 })());
13992 result
13993}
13994
13995
13996static depthMask_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13997
13998pub(crate) fn init_depthMask_methodinfo<D: DomTypes>() {
13999 depthMask_methodinfo.set(JSJitInfo {
14000 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14001 method: Some(depthMask::<D>)
14002 },
14003 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14004 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14005 },
14006 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14007 _bitfield_align_1: [],
14008 _bitfield_1: __BindgenBitfieldUnit::new(
14009 new_jsjitinfo_bitfield_1!(
14010 JSJitInfo_OpType::Method as u8,
14011 JSJitInfo_AliasSet::AliasEverything as u8,
14012 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14013 false,
14014 false,
14015 false,
14016 false,
14017 false,
14018 false,
14019 0,
14020 ).to_ne_bytes()
14021 ),
14022});
14023}
14024unsafe extern "C" fn depthRange<D: DomTypes>
14025(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14026 let mut result = false;
14027 wrap_panic(&mut || result = (|| {
14028 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14029 let this = &*(this as *const D::WebGL2RenderingContext);
14030 let args = &*args;
14031 let argc = args.argc_;
14032
14033 if argc < 2 {
14034 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.depthRange\".");
14035 return false;
14036 }
14037 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14038 Ok(ConversionResult::Success(value)) => value,
14039 Ok(ConversionResult::Failure(error)) => {
14040 throw_type_error(cx.raw_cx(), &error);
14041 return false;
14042
14043 }
14044 _ => {
14045 return false;
14046
14047 },
14048 }
14049 ;
14050 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
14051 Ok(ConversionResult::Success(value)) => value,
14052 Ok(ConversionResult::Failure(error)) => {
14053 throw_type_error(cx.raw_cx(), &error);
14054 return false;
14055
14056 }
14057 _ => {
14058 return false;
14059
14060 },
14061 }
14062 ;
14063 let result: () = this.DepthRange(arg0, arg1);
14064
14065 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14066 return true;
14067 })());
14068 result
14069}
14070
14071
14072static depthRange_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14073
14074pub(crate) fn init_depthRange_methodinfo<D: DomTypes>() {
14075 depthRange_methodinfo.set(JSJitInfo {
14076 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14077 method: Some(depthRange::<D>)
14078 },
14079 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14080 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14081 },
14082 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14083 _bitfield_align_1: [],
14084 _bitfield_1: __BindgenBitfieldUnit::new(
14085 new_jsjitinfo_bitfield_1!(
14086 JSJitInfo_OpType::Method as u8,
14087 JSJitInfo_AliasSet::AliasEverything as u8,
14088 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14089 false,
14090 false,
14091 false,
14092 false,
14093 false,
14094 false,
14095 0,
14096 ).to_ne_bytes()
14097 ),
14098});
14099}
14100unsafe extern "C" fn detachShader<D: DomTypes>
14101(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14102 let mut result = false;
14103 wrap_panic(&mut || result = (|| {
14104 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14105 let this = &*(this as *const D::WebGL2RenderingContext);
14106 let args = &*args;
14107 let argc = args.argc_;
14108
14109 if argc < 2 {
14110 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.detachShader\".");
14111 return false;
14112 }
14113 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
14114 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
14115 Ok(val) => val,
14116 Err(()) => {
14117 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
14118 return false;
14119
14120 }
14121 }
14122
14123 } else {
14124 throw_type_error(cx.raw_cx(), "Value is not an object.");
14125 return false;
14126
14127 };
14128 let arg1: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(1)).get().is_object() {
14129 match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
14130 Ok(val) => val,
14131 Err(()) => {
14132 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
14133 return false;
14134
14135 }
14136 }
14137
14138 } else {
14139 throw_type_error(cx.raw_cx(), "Value is not an object.");
14140 return false;
14141
14142 };
14143 let result: () = this.DetachShader(&arg0, &arg1);
14144
14145 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14146 return true;
14147 })());
14148 result
14149}
14150
14151
14152static detachShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14153
14154pub(crate) fn init_detachShader_methodinfo<D: DomTypes>() {
14155 detachShader_methodinfo.set(JSJitInfo {
14156 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14157 method: Some(detachShader::<D>)
14158 },
14159 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14160 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14161 },
14162 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14163 _bitfield_align_1: [],
14164 _bitfield_1: __BindgenBitfieldUnit::new(
14165 new_jsjitinfo_bitfield_1!(
14166 JSJitInfo_OpType::Method as u8,
14167 JSJitInfo_AliasSet::AliasEverything as u8,
14168 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14169 false,
14170 false,
14171 false,
14172 false,
14173 false,
14174 false,
14175 0,
14176 ).to_ne_bytes()
14177 ),
14178});
14179}
14180unsafe extern "C" fn disable<D: DomTypes>
14181(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14182 let mut result = false;
14183 wrap_panic(&mut || result = (|| {
14184 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14185 let this = &*(this as *const D::WebGL2RenderingContext);
14186 let args = &*args;
14187 let argc = args.argc_;
14188
14189 if argc < 1 {
14190 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.disable\".");
14191 return false;
14192 }
14193 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14194 Ok(ConversionResult::Success(value)) => value,
14195 Ok(ConversionResult::Failure(error)) => {
14196 throw_type_error(cx.raw_cx(), &error);
14197 return false;
14198
14199 }
14200 _ => {
14201 return false;
14202
14203 },
14204 }
14205 ;
14206 let result: () = this.Disable(arg0);
14207
14208 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14209 return true;
14210 })());
14211 result
14212}
14213
14214
14215static disable_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14216
14217pub(crate) fn init_disable_methodinfo<D: DomTypes>() {
14218 disable_methodinfo.set(JSJitInfo {
14219 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14220 method: Some(disable::<D>)
14221 },
14222 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14223 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14224 },
14225 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14226 _bitfield_align_1: [],
14227 _bitfield_1: __BindgenBitfieldUnit::new(
14228 new_jsjitinfo_bitfield_1!(
14229 JSJitInfo_OpType::Method as u8,
14230 JSJitInfo_AliasSet::AliasEverything as u8,
14231 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14232 false,
14233 false,
14234 false,
14235 false,
14236 false,
14237 false,
14238 0,
14239 ).to_ne_bytes()
14240 ),
14241});
14242}
14243unsafe extern "C" fn disableVertexAttribArray<D: DomTypes>
14244(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14245 let mut result = false;
14246 wrap_panic(&mut || result = (|| {
14247 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14248 let this = &*(this as *const D::WebGL2RenderingContext);
14249 let args = &*args;
14250 let argc = args.argc_;
14251
14252 if argc < 1 {
14253 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.disableVertexAttribArray\".");
14254 return false;
14255 }
14256 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14257 Ok(ConversionResult::Success(value)) => value,
14258 Ok(ConversionResult::Failure(error)) => {
14259 throw_type_error(cx.raw_cx(), &error);
14260 return false;
14261
14262 }
14263 _ => {
14264 return false;
14265
14266 },
14267 }
14268 ;
14269 let result: () = this.DisableVertexAttribArray(arg0);
14270
14271 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14272 return true;
14273 })());
14274 result
14275}
14276
14277
14278static disableVertexAttribArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14279
14280pub(crate) fn init_disableVertexAttribArray_methodinfo<D: DomTypes>() {
14281 disableVertexAttribArray_methodinfo.set(JSJitInfo {
14282 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14283 method: Some(disableVertexAttribArray::<D>)
14284 },
14285 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14286 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14287 },
14288 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14289 _bitfield_align_1: [],
14290 _bitfield_1: __BindgenBitfieldUnit::new(
14291 new_jsjitinfo_bitfield_1!(
14292 JSJitInfo_OpType::Method as u8,
14293 JSJitInfo_AliasSet::AliasEverything as u8,
14294 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14295 false,
14296 false,
14297 false,
14298 false,
14299 false,
14300 false,
14301 0,
14302 ).to_ne_bytes()
14303 ),
14304});
14305}
14306unsafe extern "C" fn drawArrays<D: DomTypes>
14307(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14308 let mut result = false;
14309 wrap_panic(&mut || result = (|| {
14310 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14311 let this = &*(this as *const D::WebGL2RenderingContext);
14312 let args = &*args;
14313 let argc = args.argc_;
14314
14315 if argc < 3 {
14316 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.drawArrays\".");
14317 return false;
14318 }
14319 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14320 Ok(ConversionResult::Success(value)) => value,
14321 Ok(ConversionResult::Failure(error)) => {
14322 throw_type_error(cx.raw_cx(), &error);
14323 return false;
14324
14325 }
14326 _ => {
14327 return false;
14328
14329 },
14330 }
14331 ;
14332 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
14333 Ok(ConversionResult::Success(value)) => value,
14334 Ok(ConversionResult::Failure(error)) => {
14335 throw_type_error(cx.raw_cx(), &error);
14336 return false;
14337
14338 }
14339 _ => {
14340 return false;
14341
14342 },
14343 }
14344 ;
14345 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
14346 Ok(ConversionResult::Success(value)) => value,
14347 Ok(ConversionResult::Failure(error)) => {
14348 throw_type_error(cx.raw_cx(), &error);
14349 return false;
14350
14351 }
14352 _ => {
14353 return false;
14354
14355 },
14356 }
14357 ;
14358 let result: () = this.DrawArrays(arg0, arg1, arg2);
14359
14360 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14361 return true;
14362 })());
14363 result
14364}
14365
14366
14367static drawArrays_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14368
14369pub(crate) fn init_drawArrays_methodinfo<D: DomTypes>() {
14370 drawArrays_methodinfo.set(JSJitInfo {
14371 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14372 method: Some(drawArrays::<D>)
14373 },
14374 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14375 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14376 },
14377 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14378 _bitfield_align_1: [],
14379 _bitfield_1: __BindgenBitfieldUnit::new(
14380 new_jsjitinfo_bitfield_1!(
14381 JSJitInfo_OpType::Method as u8,
14382 JSJitInfo_AliasSet::AliasEverything as u8,
14383 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14384 false,
14385 false,
14386 false,
14387 false,
14388 false,
14389 false,
14390 0,
14391 ).to_ne_bytes()
14392 ),
14393});
14394}
14395unsafe extern "C" fn drawElements<D: DomTypes>
14396(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14397 let mut result = false;
14398 wrap_panic(&mut || result = (|| {
14399 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14400 let this = &*(this as *const D::WebGL2RenderingContext);
14401 let args = &*args;
14402 let argc = args.argc_;
14403
14404 if argc < 4 {
14405 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.drawElements\".");
14406 return false;
14407 }
14408 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14409 Ok(ConversionResult::Success(value)) => value,
14410 Ok(ConversionResult::Failure(error)) => {
14411 throw_type_error(cx.raw_cx(), &error);
14412 return false;
14413
14414 }
14415 _ => {
14416 return false;
14417
14418 },
14419 }
14420 ;
14421 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
14422 Ok(ConversionResult::Success(value)) => value,
14423 Ok(ConversionResult::Failure(error)) => {
14424 throw_type_error(cx.raw_cx(), &error);
14425 return false;
14426
14427 }
14428 _ => {
14429 return false;
14430
14431 },
14432 }
14433 ;
14434 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
14435 Ok(ConversionResult::Success(value)) => value,
14436 Ok(ConversionResult::Failure(error)) => {
14437 throw_type_error(cx.raw_cx(), &error);
14438 return false;
14439
14440 }
14441 _ => {
14442 return false;
14443
14444 },
14445 }
14446 ;
14447 let arg3: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
14448 Ok(ConversionResult::Success(value)) => value,
14449 Ok(ConversionResult::Failure(error)) => {
14450 throw_type_error(cx.raw_cx(), &error);
14451 return false;
14452
14453 }
14454 _ => {
14455 return false;
14456
14457 },
14458 }
14459 ;
14460 let result: () = this.DrawElements(arg0, arg1, arg2, arg3);
14461
14462 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14463 return true;
14464 })());
14465 result
14466}
14467
14468
14469static drawElements_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14470
14471pub(crate) fn init_drawElements_methodinfo<D: DomTypes>() {
14472 drawElements_methodinfo.set(JSJitInfo {
14473 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14474 method: Some(drawElements::<D>)
14475 },
14476 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14477 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14478 },
14479 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14480 _bitfield_align_1: [],
14481 _bitfield_1: __BindgenBitfieldUnit::new(
14482 new_jsjitinfo_bitfield_1!(
14483 JSJitInfo_OpType::Method as u8,
14484 JSJitInfo_AliasSet::AliasEverything as u8,
14485 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14486 false,
14487 false,
14488 false,
14489 false,
14490 false,
14491 false,
14492 0,
14493 ).to_ne_bytes()
14494 ),
14495});
14496}
14497unsafe extern "C" fn enable<D: DomTypes>
14498(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14499 let mut result = false;
14500 wrap_panic(&mut || result = (|| {
14501 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14502 let this = &*(this as *const D::WebGL2RenderingContext);
14503 let args = &*args;
14504 let argc = args.argc_;
14505
14506 if argc < 1 {
14507 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.enable\".");
14508 return false;
14509 }
14510 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14511 Ok(ConversionResult::Success(value)) => value,
14512 Ok(ConversionResult::Failure(error)) => {
14513 throw_type_error(cx.raw_cx(), &error);
14514 return false;
14515
14516 }
14517 _ => {
14518 return false;
14519
14520 },
14521 }
14522 ;
14523 let result: () = this.Enable(arg0);
14524
14525 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14526 return true;
14527 })());
14528 result
14529}
14530
14531
14532static enable_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14533
14534pub(crate) fn init_enable_methodinfo<D: DomTypes>() {
14535 enable_methodinfo.set(JSJitInfo {
14536 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14537 method: Some(enable::<D>)
14538 },
14539 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14540 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14541 },
14542 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14543 _bitfield_align_1: [],
14544 _bitfield_1: __BindgenBitfieldUnit::new(
14545 new_jsjitinfo_bitfield_1!(
14546 JSJitInfo_OpType::Method as u8,
14547 JSJitInfo_AliasSet::AliasEverything as u8,
14548 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14549 false,
14550 false,
14551 false,
14552 false,
14553 false,
14554 false,
14555 0,
14556 ).to_ne_bytes()
14557 ),
14558});
14559}
14560unsafe extern "C" fn enableVertexAttribArray<D: DomTypes>
14561(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14562 let mut result = false;
14563 wrap_panic(&mut || result = (|| {
14564 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14565 let this = &*(this as *const D::WebGL2RenderingContext);
14566 let args = &*args;
14567 let argc = args.argc_;
14568
14569 if argc < 1 {
14570 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.enableVertexAttribArray\".");
14571 return false;
14572 }
14573 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14574 Ok(ConversionResult::Success(value)) => value,
14575 Ok(ConversionResult::Failure(error)) => {
14576 throw_type_error(cx.raw_cx(), &error);
14577 return false;
14578
14579 }
14580 _ => {
14581 return false;
14582
14583 },
14584 }
14585 ;
14586 let result: () = this.EnableVertexAttribArray(arg0);
14587
14588 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14589 return true;
14590 })());
14591 result
14592}
14593
14594
14595static enableVertexAttribArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14596
14597pub(crate) fn init_enableVertexAttribArray_methodinfo<D: DomTypes>() {
14598 enableVertexAttribArray_methodinfo.set(JSJitInfo {
14599 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14600 method: Some(enableVertexAttribArray::<D>)
14601 },
14602 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14603 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14604 },
14605 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14606 _bitfield_align_1: [],
14607 _bitfield_1: __BindgenBitfieldUnit::new(
14608 new_jsjitinfo_bitfield_1!(
14609 JSJitInfo_OpType::Method as u8,
14610 JSJitInfo_AliasSet::AliasEverything as u8,
14611 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14612 false,
14613 false,
14614 false,
14615 false,
14616 false,
14617 false,
14618 0,
14619 ).to_ne_bytes()
14620 ),
14621});
14622}
14623unsafe extern "C" fn finish<D: DomTypes>
14624(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14625 let mut result = false;
14626 wrap_panic(&mut || result = (|| {
14627 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14628 let this = &*(this as *const D::WebGL2RenderingContext);
14629 let args = &*args;
14630 let argc = args.argc_;
14631 let result: () = this.Finish();
14632
14633 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14634 return true;
14635 })());
14636 result
14637}
14638
14639
14640static finish_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14641
14642pub(crate) fn init_finish_methodinfo<D: DomTypes>() {
14643 finish_methodinfo.set(JSJitInfo {
14644 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14645 method: Some(finish::<D>)
14646 },
14647 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14648 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14649 },
14650 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14651 _bitfield_align_1: [],
14652 _bitfield_1: __BindgenBitfieldUnit::new(
14653 new_jsjitinfo_bitfield_1!(
14654 JSJitInfo_OpType::Method as u8,
14655 JSJitInfo_AliasSet::AliasEverything as u8,
14656 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14657 true,
14658 false,
14659 false,
14660 false,
14661 false,
14662 false,
14663 0,
14664 ).to_ne_bytes()
14665 ),
14666});
14667}
14668unsafe extern "C" fn flush<D: DomTypes>
14669(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14670 let mut result = false;
14671 wrap_panic(&mut || result = (|| {
14672 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14673 let this = &*(this as *const D::WebGL2RenderingContext);
14674 let args = &*args;
14675 let argc = args.argc_;
14676 let result: () = this.Flush();
14677
14678 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14679 return true;
14680 })());
14681 result
14682}
14683
14684
14685static flush_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14686
14687pub(crate) fn init_flush_methodinfo<D: DomTypes>() {
14688 flush_methodinfo.set(JSJitInfo {
14689 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14690 method: Some(flush::<D>)
14691 },
14692 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14693 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14694 },
14695 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14696 _bitfield_align_1: [],
14697 _bitfield_1: __BindgenBitfieldUnit::new(
14698 new_jsjitinfo_bitfield_1!(
14699 JSJitInfo_OpType::Method as u8,
14700 JSJitInfo_AliasSet::AliasEverything as u8,
14701 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14702 true,
14703 false,
14704 false,
14705 false,
14706 false,
14707 false,
14708 0,
14709 ).to_ne_bytes()
14710 ),
14711});
14712}
14713unsafe extern "C" fn framebufferRenderbuffer<D: DomTypes>
14714(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14715 let mut result = false;
14716 wrap_panic(&mut || result = (|| {
14717 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14718 let this = &*(this as *const D::WebGL2RenderingContext);
14719 let args = &*args;
14720 let argc = args.argc_;
14721
14722 if argc < 4 {
14723 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.framebufferRenderbuffer\".");
14724 return false;
14725 }
14726 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14727 Ok(ConversionResult::Success(value)) => value,
14728 Ok(ConversionResult::Failure(error)) => {
14729 throw_type_error(cx.raw_cx(), &error);
14730 return false;
14731
14732 }
14733 _ => {
14734 return false;
14735
14736 },
14737 }
14738 ;
14739 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
14740 Ok(ConversionResult::Success(value)) => value,
14741 Ok(ConversionResult::Failure(error)) => {
14742 throw_type_error(cx.raw_cx(), &error);
14743 return false;
14744
14745 }
14746 _ => {
14747 return false;
14748
14749 },
14750 }
14751 ;
14752 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
14753 Ok(ConversionResult::Success(value)) => value,
14754 Ok(ConversionResult::Failure(error)) => {
14755 throw_type_error(cx.raw_cx(), &error);
14756 return false;
14757
14758 }
14759 _ => {
14760 return false;
14761
14762 },
14763 }
14764 ;
14765 let arg3: Option<DomRoot<D::WebGLRenderbuffer>> = if HandleValue::from_raw(args.get(3)).get().is_object() {
14766 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(3)), SafeJSContext::from_ptr(cx.raw_cx())) {
14767 Ok(val) => val,
14768 Err(()) => {
14769 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLRenderbuffer.");
14770 return false;
14771
14772 }
14773 }
14774 )
14775 } else if HandleValue::from_raw(args.get(3)).get().is_null_or_undefined() {
14776 None
14777 } else {
14778 throw_type_error(cx.raw_cx(), "Value is not an object.");
14779 return false;
14780
14781 };
14782 let result: () = this.FramebufferRenderbuffer(arg0, arg1, arg2, arg3.as_deref());
14783
14784 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14785 return true;
14786 })());
14787 result
14788}
14789
14790
14791static framebufferRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14792
14793pub(crate) fn init_framebufferRenderbuffer_methodinfo<D: DomTypes>() {
14794 framebufferRenderbuffer_methodinfo.set(JSJitInfo {
14795 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14796 method: Some(framebufferRenderbuffer::<D>)
14797 },
14798 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14799 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14800 },
14801 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14802 _bitfield_align_1: [],
14803 _bitfield_1: __BindgenBitfieldUnit::new(
14804 new_jsjitinfo_bitfield_1!(
14805 JSJitInfo_OpType::Method as u8,
14806 JSJitInfo_AliasSet::AliasEverything as u8,
14807 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14808 false,
14809 false,
14810 false,
14811 false,
14812 false,
14813 false,
14814 0,
14815 ).to_ne_bytes()
14816 ),
14817});
14818}
14819unsafe extern "C" fn framebufferTexture2D<D: DomTypes>
14820(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14821 let mut result = false;
14822 wrap_panic(&mut || result = (|| {
14823 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14824 let this = &*(this as *const D::WebGL2RenderingContext);
14825 let args = &*args;
14826 let argc = args.argc_;
14827
14828 if argc < 5 {
14829 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.framebufferTexture2D\".");
14830 return false;
14831 }
14832 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14833 Ok(ConversionResult::Success(value)) => value,
14834 Ok(ConversionResult::Failure(error)) => {
14835 throw_type_error(cx.raw_cx(), &error);
14836 return false;
14837
14838 }
14839 _ => {
14840 return false;
14841
14842 },
14843 }
14844 ;
14845 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
14846 Ok(ConversionResult::Success(value)) => value,
14847 Ok(ConversionResult::Failure(error)) => {
14848 throw_type_error(cx.raw_cx(), &error);
14849 return false;
14850
14851 }
14852 _ => {
14853 return false;
14854
14855 },
14856 }
14857 ;
14858 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
14859 Ok(ConversionResult::Success(value)) => value,
14860 Ok(ConversionResult::Failure(error)) => {
14861 throw_type_error(cx.raw_cx(), &error);
14862 return false;
14863
14864 }
14865 _ => {
14866 return false;
14867
14868 },
14869 }
14870 ;
14871 let arg3: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(3)).get().is_object() {
14872 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(3)), SafeJSContext::from_ptr(cx.raw_cx())) {
14873 Ok(val) => val,
14874 Err(()) => {
14875 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
14876 return false;
14877
14878 }
14879 }
14880 )
14881 } else if HandleValue::from_raw(args.get(3)).get().is_null_or_undefined() {
14882 None
14883 } else {
14884 throw_type_error(cx.raw_cx(), "Value is not an object.");
14885 return false;
14886
14887 };
14888 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
14889 Ok(ConversionResult::Success(value)) => value,
14890 Ok(ConversionResult::Failure(error)) => {
14891 throw_type_error(cx.raw_cx(), &error);
14892 return false;
14893
14894 }
14895 _ => {
14896 return false;
14897
14898 },
14899 }
14900 ;
14901 let result: () = this.FramebufferTexture2D(arg0, arg1, arg2, arg3.as_deref(), arg4);
14902
14903 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14904 return true;
14905 })());
14906 result
14907}
14908
14909
14910static framebufferTexture2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14911
14912pub(crate) fn init_framebufferTexture2D_methodinfo<D: DomTypes>() {
14913 framebufferTexture2D_methodinfo.set(JSJitInfo {
14914 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14915 method: Some(framebufferTexture2D::<D>)
14916 },
14917 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14918 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14919 },
14920 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14921 _bitfield_align_1: [],
14922 _bitfield_1: __BindgenBitfieldUnit::new(
14923 new_jsjitinfo_bitfield_1!(
14924 JSJitInfo_OpType::Method as u8,
14925 JSJitInfo_AliasSet::AliasEverything as u8,
14926 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14927 false,
14928 false,
14929 false,
14930 false,
14931 false,
14932 false,
14933 0,
14934 ).to_ne_bytes()
14935 ),
14936});
14937}
14938unsafe extern "C" fn frontFace<D: DomTypes>
14939(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14940 let mut result = false;
14941 wrap_panic(&mut || result = (|| {
14942 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14943 let this = &*(this as *const D::WebGL2RenderingContext);
14944 let args = &*args;
14945 let argc = args.argc_;
14946
14947 if argc < 1 {
14948 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.frontFace\".");
14949 return false;
14950 }
14951 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14952 Ok(ConversionResult::Success(value)) => value,
14953 Ok(ConversionResult::Failure(error)) => {
14954 throw_type_error(cx.raw_cx(), &error);
14955 return false;
14956
14957 }
14958 _ => {
14959 return false;
14960
14961 },
14962 }
14963 ;
14964 let result: () = this.FrontFace(arg0);
14965
14966 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14967 return true;
14968 })());
14969 result
14970}
14971
14972
14973static frontFace_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14974
14975pub(crate) fn init_frontFace_methodinfo<D: DomTypes>() {
14976 frontFace_methodinfo.set(JSJitInfo {
14977 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14978 method: Some(frontFace::<D>)
14979 },
14980 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14981 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
14982 },
14983 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14984 _bitfield_align_1: [],
14985 _bitfield_1: __BindgenBitfieldUnit::new(
14986 new_jsjitinfo_bitfield_1!(
14987 JSJitInfo_OpType::Method as u8,
14988 JSJitInfo_AliasSet::AliasEverything as u8,
14989 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14990 false,
14991 false,
14992 false,
14993 false,
14994 false,
14995 false,
14996 0,
14997 ).to_ne_bytes()
14998 ),
14999});
15000}
15001unsafe extern "C" fn generateMipmap<D: DomTypes>
15002(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15003 let mut result = false;
15004 wrap_panic(&mut || result = (|| {
15005 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15006 let this = &*(this as *const D::WebGL2RenderingContext);
15007 let args = &*args;
15008 let argc = args.argc_;
15009
15010 if argc < 1 {
15011 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.generateMipmap\".");
15012 return false;
15013 }
15014 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15015 Ok(ConversionResult::Success(value)) => value,
15016 Ok(ConversionResult::Failure(error)) => {
15017 throw_type_error(cx.raw_cx(), &error);
15018 return false;
15019
15020 }
15021 _ => {
15022 return false;
15023
15024 },
15025 }
15026 ;
15027 let result: () = this.GenerateMipmap(arg0);
15028
15029 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15030 return true;
15031 })());
15032 result
15033}
15034
15035
15036static generateMipmap_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15037
15038pub(crate) fn init_generateMipmap_methodinfo<D: DomTypes>() {
15039 generateMipmap_methodinfo.set(JSJitInfo {
15040 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15041 method: Some(generateMipmap::<D>)
15042 },
15043 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15044 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15045 },
15046 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15047 _bitfield_align_1: [],
15048 _bitfield_1: __BindgenBitfieldUnit::new(
15049 new_jsjitinfo_bitfield_1!(
15050 JSJitInfo_OpType::Method as u8,
15051 JSJitInfo_AliasSet::AliasEverything as u8,
15052 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15053 false,
15054 false,
15055 false,
15056 false,
15057 false,
15058 false,
15059 0,
15060 ).to_ne_bytes()
15061 ),
15062});
15063}
15064unsafe extern "C" fn getActiveAttrib<D: DomTypes>
15065(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15066 let mut result = false;
15067 wrap_panic(&mut || result = (|| {
15068 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15069 let this = &*(this as *const D::WebGL2RenderingContext);
15070 let args = &*args;
15071 let argc = args.argc_;
15072
15073 if argc < 2 {
15074 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getActiveAttrib\".");
15075 return false;
15076 }
15077 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15078 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
15079 Ok(val) => val,
15080 Err(()) => {
15081 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
15082 return false;
15083
15084 }
15085 }
15086
15087 } else {
15088 throw_type_error(cx.raw_cx(), "Value is not an object.");
15089 return false;
15090
15091 };
15092 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15093 Ok(ConversionResult::Success(value)) => value,
15094 Ok(ConversionResult::Failure(error)) => {
15095 throw_type_error(cx.raw_cx(), &error);
15096 return false;
15097
15098 }
15099 _ => {
15100 return false;
15101
15102 },
15103 }
15104 ;
15105 let result: Option<DomRoot<D::WebGLActiveInfo>> = this.GetActiveAttrib(&arg0, arg1);
15106
15107 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15108 return true;
15109 })());
15110 result
15111}
15112
15113
15114static getActiveAttrib_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15115
15116pub(crate) fn init_getActiveAttrib_methodinfo<D: DomTypes>() {
15117 getActiveAttrib_methodinfo.set(JSJitInfo {
15118 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15119 method: Some(getActiveAttrib::<D>)
15120 },
15121 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15122 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15123 },
15124 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15125 _bitfield_align_1: [],
15126 _bitfield_1: __BindgenBitfieldUnit::new(
15127 new_jsjitinfo_bitfield_1!(
15128 JSJitInfo_OpType::Method as u8,
15129 JSJitInfo_AliasSet::AliasEverything as u8,
15130 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15131 false,
15132 false,
15133 false,
15134 false,
15135 false,
15136 false,
15137 0,
15138 ).to_ne_bytes()
15139 ),
15140});
15141}
15142unsafe extern "C" fn getActiveUniform<D: DomTypes>
15143(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15144 let mut result = false;
15145 wrap_panic(&mut || result = (|| {
15146 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15147 let this = &*(this as *const D::WebGL2RenderingContext);
15148 let args = &*args;
15149 let argc = args.argc_;
15150
15151 if argc < 2 {
15152 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getActiveUniform\".");
15153 return false;
15154 }
15155 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15156 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
15157 Ok(val) => val,
15158 Err(()) => {
15159 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
15160 return false;
15161
15162 }
15163 }
15164
15165 } else {
15166 throw_type_error(cx.raw_cx(), "Value is not an object.");
15167 return false;
15168
15169 };
15170 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15171 Ok(ConversionResult::Success(value)) => value,
15172 Ok(ConversionResult::Failure(error)) => {
15173 throw_type_error(cx.raw_cx(), &error);
15174 return false;
15175
15176 }
15177 _ => {
15178 return false;
15179
15180 },
15181 }
15182 ;
15183 let result: Option<DomRoot<D::WebGLActiveInfo>> = this.GetActiveUniform(&arg0, arg1);
15184
15185 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15186 return true;
15187 })());
15188 result
15189}
15190
15191
15192static getActiveUniform_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15193
15194pub(crate) fn init_getActiveUniform_methodinfo<D: DomTypes>() {
15195 getActiveUniform_methodinfo.set(JSJitInfo {
15196 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15197 method: Some(getActiveUniform::<D>)
15198 },
15199 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15200 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15201 },
15202 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15203 _bitfield_align_1: [],
15204 _bitfield_1: __BindgenBitfieldUnit::new(
15205 new_jsjitinfo_bitfield_1!(
15206 JSJitInfo_OpType::Method as u8,
15207 JSJitInfo_AliasSet::AliasEverything as u8,
15208 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15209 false,
15210 false,
15211 false,
15212 false,
15213 false,
15214 false,
15215 0,
15216 ).to_ne_bytes()
15217 ),
15218});
15219}
15220unsafe extern "C" fn getAttachedShaders<D: DomTypes>
15221(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15222 let mut result = false;
15223 wrap_panic(&mut || result = (|| {
15224 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15225 let this = &*(this as *const D::WebGL2RenderingContext);
15226 let args = &*args;
15227 let argc = args.argc_;
15228
15229 if argc < 1 {
15230 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getAttachedShaders\".");
15231 return false;
15232 }
15233 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15234 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
15235 Ok(val) => val,
15236 Err(()) => {
15237 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
15238 return false;
15239
15240 }
15241 }
15242
15243 } else {
15244 throw_type_error(cx.raw_cx(), "Value is not an object.");
15245 return false;
15246
15247 };
15248 let result: Option<Vec<DomRoot<D::WebGLShader>>> = this.GetAttachedShaders(&arg0);
15249
15250 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15251 return true;
15252 })());
15253 result
15254}
15255
15256
15257static getAttachedShaders_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15258
15259pub(crate) fn init_getAttachedShaders_methodinfo<D: DomTypes>() {
15260 getAttachedShaders_methodinfo.set(JSJitInfo {
15261 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15262 method: Some(getAttachedShaders::<D>)
15263 },
15264 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15265 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15266 },
15267 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15268 _bitfield_align_1: [],
15269 _bitfield_1: __BindgenBitfieldUnit::new(
15270 new_jsjitinfo_bitfield_1!(
15271 JSJitInfo_OpType::Method as u8,
15272 JSJitInfo_AliasSet::AliasEverything as u8,
15273 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15274 false,
15275 false,
15276 false,
15277 false,
15278 false,
15279 false,
15280 0,
15281 ).to_ne_bytes()
15282 ),
15283});
15284}
15285unsafe extern "C" fn getAttribLocation<D: DomTypes>
15286(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15287 let mut result = false;
15288 wrap_panic(&mut || result = (|| {
15289 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15290 let this = &*(this as *const D::WebGL2RenderingContext);
15291 let args = &*args;
15292 let argc = args.argc_;
15293
15294 if argc < 2 {
15295 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getAttribLocation\".");
15296 return false;
15297 }
15298 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15299 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
15300 Ok(val) => val,
15301 Err(()) => {
15302 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
15303 return false;
15304
15305 }
15306 }
15307
15308 } else {
15309 throw_type_error(cx.raw_cx(), "Value is not an object.");
15310 return false;
15311
15312 };
15313 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
15314 Ok(ConversionResult::Success(value)) => value,
15315 Ok(ConversionResult::Failure(error)) => {
15316 throw_type_error(cx.raw_cx(), &error);
15317 return false;
15318
15319 }
15320 _ => {
15321 return false;
15322
15323 },
15324 }
15325 ;
15326 let result: i32 = this.GetAttribLocation(&arg0, arg1);
15327
15328 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15329 return true;
15330 })());
15331 result
15332}
15333
15334
15335static getAttribLocation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15336
15337pub(crate) fn init_getAttribLocation_methodinfo<D: DomTypes>() {
15338 getAttribLocation_methodinfo.set(JSJitInfo {
15339 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15340 method: Some(getAttribLocation::<D>)
15341 },
15342 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15343 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15344 },
15345 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15346 _bitfield_align_1: [],
15347 _bitfield_1: __BindgenBitfieldUnit::new(
15348 new_jsjitinfo_bitfield_1!(
15349 JSJitInfo_OpType::Method as u8,
15350 JSJitInfo_AliasSet::AliasEverything as u8,
15351 JSValueType::JSVAL_TYPE_INT32 as u8,
15352 false,
15353 false,
15354 false,
15355 false,
15356 false,
15357 false,
15358 0,
15359 ).to_ne_bytes()
15360 ),
15361});
15362}
15363unsafe extern "C" fn getBufferParameter<D: DomTypes>
15364(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15365 let mut result = false;
15366 wrap_panic(&mut || result = (|| {
15367 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15368 let this = &*(this as *const D::WebGL2RenderingContext);
15369 let args = &*args;
15370 let argc = args.argc_;
15371
15372 if argc < 2 {
15373 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getBufferParameter\".");
15374 return false;
15375 }
15376 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15377 Ok(ConversionResult::Success(value)) => value,
15378 Ok(ConversionResult::Failure(error)) => {
15379 throw_type_error(cx.raw_cx(), &error);
15380 return false;
15381
15382 }
15383 _ => {
15384 return false;
15385
15386 },
15387 }
15388 ;
15389 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15390 Ok(ConversionResult::Success(value)) => value,
15391 Ok(ConversionResult::Failure(error)) => {
15392 throw_type_error(cx.raw_cx(), &error);
15393 return false;
15394
15395 }
15396 _ => {
15397 return false;
15398
15399 },
15400 }
15401 ;
15402 rooted!(&in(cx) let mut retval: JSVal);
15403 let result: () = this.GetBufferParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
15404
15405 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15406 return true;
15407 })());
15408 result
15409}
15410
15411
15412static getBufferParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15413
15414pub(crate) fn init_getBufferParameter_methodinfo<D: DomTypes>() {
15415 getBufferParameter_methodinfo.set(JSJitInfo {
15416 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15417 method: Some(getBufferParameter::<D>)
15418 },
15419 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15420 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15421 },
15422 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15423 _bitfield_align_1: [],
15424 _bitfield_1: __BindgenBitfieldUnit::new(
15425 new_jsjitinfo_bitfield_1!(
15426 JSJitInfo_OpType::Method as u8,
15427 JSJitInfo_AliasSet::AliasEverything as u8,
15428 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15429 false,
15430 false,
15431 false,
15432 false,
15433 false,
15434 false,
15435 0,
15436 ).to_ne_bytes()
15437 ),
15438});
15439}
15440unsafe extern "C" fn getParameter<D: DomTypes>
15441(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15442 let mut result = false;
15443 wrap_panic(&mut || result = (|| {
15444 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15445 let this = &*(this as *const D::WebGL2RenderingContext);
15446 let args = &*args;
15447 let argc = args.argc_;
15448
15449 if argc < 1 {
15450 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getParameter\".");
15451 return false;
15452 }
15453 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15454 Ok(ConversionResult::Success(value)) => value,
15455 Ok(ConversionResult::Failure(error)) => {
15456 throw_type_error(cx.raw_cx(), &error);
15457 return false;
15458
15459 }
15460 _ => {
15461 return false;
15462
15463 },
15464 }
15465 ;
15466 rooted!(&in(cx) let mut retval: JSVal);
15467 let result: () = this.GetParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, retval.handle_mut());
15468
15469 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15470 return true;
15471 })());
15472 result
15473}
15474
15475
15476static getParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15477
15478pub(crate) fn init_getParameter_methodinfo<D: DomTypes>() {
15479 getParameter_methodinfo.set(JSJitInfo {
15480 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15481 method: Some(getParameter::<D>)
15482 },
15483 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15484 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15485 },
15486 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15487 _bitfield_align_1: [],
15488 _bitfield_1: __BindgenBitfieldUnit::new(
15489 new_jsjitinfo_bitfield_1!(
15490 JSJitInfo_OpType::Method as u8,
15491 JSJitInfo_AliasSet::AliasEverything as u8,
15492 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15493 false,
15494 false,
15495 false,
15496 false,
15497 false,
15498 false,
15499 0,
15500 ).to_ne_bytes()
15501 ),
15502});
15503}
15504unsafe extern "C" fn getError<D: DomTypes>
15505(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15506 let mut result = false;
15507 wrap_panic(&mut || result = (|| {
15508 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15509 let this = &*(this as *const D::WebGL2RenderingContext);
15510 let args = &*args;
15511 let argc = args.argc_;
15512 let result: u32 = this.GetError();
15513
15514 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15515 return true;
15516 })());
15517 result
15518}
15519
15520
15521static getError_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15522
15523pub(crate) fn init_getError_methodinfo<D: DomTypes>() {
15524 getError_methodinfo.set(JSJitInfo {
15525 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15526 method: Some(getError::<D>)
15527 },
15528 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15529 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15530 },
15531 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15532 _bitfield_align_1: [],
15533 _bitfield_1: __BindgenBitfieldUnit::new(
15534 new_jsjitinfo_bitfield_1!(
15535 JSJitInfo_OpType::Method as u8,
15536 JSJitInfo_AliasSet::AliasEverything as u8,
15537 JSValueType::JSVAL_TYPE_DOUBLE as u8,
15538 true,
15539 false,
15540 false,
15541 false,
15542 false,
15543 false,
15544 0,
15545 ).to_ne_bytes()
15546 ),
15547});
15548}
15549unsafe extern "C" fn getFramebufferAttachmentParameter<D: DomTypes>
15550(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15551 let mut result = false;
15552 wrap_panic(&mut || result = (|| {
15553 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15554 let this = &*(this as *const D::WebGL2RenderingContext);
15555 let args = &*args;
15556 let argc = args.argc_;
15557
15558 if argc < 3 {
15559 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getFramebufferAttachmentParameter\".");
15560 return false;
15561 }
15562 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15563 Ok(ConversionResult::Success(value)) => value,
15564 Ok(ConversionResult::Failure(error)) => {
15565 throw_type_error(cx.raw_cx(), &error);
15566 return false;
15567
15568 }
15569 _ => {
15570 return false;
15571
15572 },
15573 }
15574 ;
15575 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15576 Ok(ConversionResult::Success(value)) => value,
15577 Ok(ConversionResult::Failure(error)) => {
15578 throw_type_error(cx.raw_cx(), &error);
15579 return false;
15580
15581 }
15582 _ => {
15583 return false;
15584
15585 },
15586 }
15587 ;
15588 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
15589 Ok(ConversionResult::Success(value)) => value,
15590 Ok(ConversionResult::Failure(error)) => {
15591 throw_type_error(cx.raw_cx(), &error);
15592 return false;
15593
15594 }
15595 _ => {
15596 return false;
15597
15598 },
15599 }
15600 ;
15601 rooted!(&in(cx) let mut retval: JSVal);
15602 let result: () = this.GetFramebufferAttachmentParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, arg2, retval.handle_mut());
15603
15604 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15605 return true;
15606 })());
15607 result
15608}
15609
15610
15611static getFramebufferAttachmentParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15612
15613pub(crate) fn init_getFramebufferAttachmentParameter_methodinfo<D: DomTypes>() {
15614 getFramebufferAttachmentParameter_methodinfo.set(JSJitInfo {
15615 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15616 method: Some(getFramebufferAttachmentParameter::<D>)
15617 },
15618 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15619 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15620 },
15621 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15622 _bitfield_align_1: [],
15623 _bitfield_1: __BindgenBitfieldUnit::new(
15624 new_jsjitinfo_bitfield_1!(
15625 JSJitInfo_OpType::Method as u8,
15626 JSJitInfo_AliasSet::AliasEverything as u8,
15627 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15628 false,
15629 false,
15630 false,
15631 false,
15632 false,
15633 false,
15634 0,
15635 ).to_ne_bytes()
15636 ),
15637});
15638}
15639unsafe extern "C" fn getProgramParameter<D: DomTypes>
15640(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15641 let mut result = false;
15642 wrap_panic(&mut || result = (|| {
15643 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15644 let this = &*(this as *const D::WebGL2RenderingContext);
15645 let args = &*args;
15646 let argc = args.argc_;
15647
15648 if argc < 2 {
15649 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getProgramParameter\".");
15650 return false;
15651 }
15652 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15653 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
15654 Ok(val) => val,
15655 Err(()) => {
15656 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
15657 return false;
15658
15659 }
15660 }
15661
15662 } else {
15663 throw_type_error(cx.raw_cx(), "Value is not an object.");
15664 return false;
15665
15666 };
15667 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15668 Ok(ConversionResult::Success(value)) => value,
15669 Ok(ConversionResult::Failure(error)) => {
15670 throw_type_error(cx.raw_cx(), &error);
15671 return false;
15672
15673 }
15674 _ => {
15675 return false;
15676
15677 },
15678 }
15679 ;
15680 rooted!(&in(cx) let mut retval: JSVal);
15681 let result: () = this.GetProgramParameter(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, retval.handle_mut());
15682
15683 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15684 return true;
15685 })());
15686 result
15687}
15688
15689
15690static getProgramParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15691
15692pub(crate) fn init_getProgramParameter_methodinfo<D: DomTypes>() {
15693 getProgramParameter_methodinfo.set(JSJitInfo {
15694 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15695 method: Some(getProgramParameter::<D>)
15696 },
15697 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15698 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15699 },
15700 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15701 _bitfield_align_1: [],
15702 _bitfield_1: __BindgenBitfieldUnit::new(
15703 new_jsjitinfo_bitfield_1!(
15704 JSJitInfo_OpType::Method as u8,
15705 JSJitInfo_AliasSet::AliasEverything as u8,
15706 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15707 false,
15708 false,
15709 false,
15710 false,
15711 false,
15712 false,
15713 0,
15714 ).to_ne_bytes()
15715 ),
15716});
15717}
15718unsafe extern "C" fn getProgramInfoLog<D: DomTypes>
15719(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15720 let mut result = false;
15721 wrap_panic(&mut || result = (|| {
15722 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15723 let this = &*(this as *const D::WebGL2RenderingContext);
15724 let args = &*args;
15725 let argc = args.argc_;
15726
15727 if argc < 1 {
15728 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getProgramInfoLog\".");
15729 return false;
15730 }
15731 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15732 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
15733 Ok(val) => val,
15734 Err(()) => {
15735 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
15736 return false;
15737
15738 }
15739 }
15740
15741 } else {
15742 throw_type_error(cx.raw_cx(), "Value is not an object.");
15743 return false;
15744
15745 };
15746 let result: Option<DOMString> = this.GetProgramInfoLog(&arg0);
15747
15748 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15749 return true;
15750 })());
15751 result
15752}
15753
15754
15755static getProgramInfoLog_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15756
15757pub(crate) fn init_getProgramInfoLog_methodinfo<D: DomTypes>() {
15758 getProgramInfoLog_methodinfo.set(JSJitInfo {
15759 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15760 method: Some(getProgramInfoLog::<D>)
15761 },
15762 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15763 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15764 },
15765 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15766 _bitfield_align_1: [],
15767 _bitfield_1: __BindgenBitfieldUnit::new(
15768 new_jsjitinfo_bitfield_1!(
15769 JSJitInfo_OpType::Method as u8,
15770 JSJitInfo_AliasSet::AliasEverything as u8,
15771 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15772 false,
15773 false,
15774 false,
15775 false,
15776 false,
15777 false,
15778 0,
15779 ).to_ne_bytes()
15780 ),
15781});
15782}
15783unsafe extern "C" fn getRenderbufferParameter<D: DomTypes>
15784(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15785 let mut result = false;
15786 wrap_panic(&mut || result = (|| {
15787 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15788 let this = &*(this as *const D::WebGL2RenderingContext);
15789 let args = &*args;
15790 let argc = args.argc_;
15791
15792 if argc < 2 {
15793 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getRenderbufferParameter\".");
15794 return false;
15795 }
15796 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15797 Ok(ConversionResult::Success(value)) => value,
15798 Ok(ConversionResult::Failure(error)) => {
15799 throw_type_error(cx.raw_cx(), &error);
15800 return false;
15801
15802 }
15803 _ => {
15804 return false;
15805
15806 },
15807 }
15808 ;
15809 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15810 Ok(ConversionResult::Success(value)) => value,
15811 Ok(ConversionResult::Failure(error)) => {
15812 throw_type_error(cx.raw_cx(), &error);
15813 return false;
15814
15815 }
15816 _ => {
15817 return false;
15818
15819 },
15820 }
15821 ;
15822 rooted!(&in(cx) let mut retval: JSVal);
15823 let result: () = this.GetRenderbufferParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
15824
15825 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15826 return true;
15827 })());
15828 result
15829}
15830
15831
15832static getRenderbufferParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15833
15834pub(crate) fn init_getRenderbufferParameter_methodinfo<D: DomTypes>() {
15835 getRenderbufferParameter_methodinfo.set(JSJitInfo {
15836 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15837 method: Some(getRenderbufferParameter::<D>)
15838 },
15839 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15840 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15841 },
15842 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15843 _bitfield_align_1: [],
15844 _bitfield_1: __BindgenBitfieldUnit::new(
15845 new_jsjitinfo_bitfield_1!(
15846 JSJitInfo_OpType::Method as u8,
15847 JSJitInfo_AliasSet::AliasEverything as u8,
15848 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15849 false,
15850 false,
15851 false,
15852 false,
15853 false,
15854 false,
15855 0,
15856 ).to_ne_bytes()
15857 ),
15858});
15859}
15860unsafe extern "C" fn getShaderParameter<D: DomTypes>
15861(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15862 let mut result = false;
15863 wrap_panic(&mut || result = (|| {
15864 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15865 let this = &*(this as *const D::WebGL2RenderingContext);
15866 let args = &*args;
15867 let argc = args.argc_;
15868
15869 if argc < 2 {
15870 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getShaderParameter\".");
15871 return false;
15872 }
15873 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15874 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
15875 Ok(val) => val,
15876 Err(()) => {
15877 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
15878 return false;
15879
15880 }
15881 }
15882
15883 } else {
15884 throw_type_error(cx.raw_cx(), "Value is not an object.");
15885 return false;
15886
15887 };
15888 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15889 Ok(ConversionResult::Success(value)) => value,
15890 Ok(ConversionResult::Failure(error)) => {
15891 throw_type_error(cx.raw_cx(), &error);
15892 return false;
15893
15894 }
15895 _ => {
15896 return false;
15897
15898 },
15899 }
15900 ;
15901 rooted!(&in(cx) let mut retval: JSVal);
15902 let result: () = this.GetShaderParameter(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, retval.handle_mut());
15903
15904 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15905 return true;
15906 })());
15907 result
15908}
15909
15910
15911static getShaderParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15912
15913pub(crate) fn init_getShaderParameter_methodinfo<D: DomTypes>() {
15914 getShaderParameter_methodinfo.set(JSJitInfo {
15915 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15916 method: Some(getShaderParameter::<D>)
15917 },
15918 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15919 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15920 },
15921 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15922 _bitfield_align_1: [],
15923 _bitfield_1: __BindgenBitfieldUnit::new(
15924 new_jsjitinfo_bitfield_1!(
15925 JSJitInfo_OpType::Method as u8,
15926 JSJitInfo_AliasSet::AliasEverything as u8,
15927 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
15928 false,
15929 false,
15930 false,
15931 false,
15932 false,
15933 false,
15934 0,
15935 ).to_ne_bytes()
15936 ),
15937});
15938}
15939unsafe extern "C" fn getShaderPrecisionFormat<D: DomTypes>
15940(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15941 let mut result = false;
15942 wrap_panic(&mut || result = (|| {
15943 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15944 let this = &*(this as *const D::WebGL2RenderingContext);
15945 let args = &*args;
15946 let argc = args.argc_;
15947
15948 if argc < 2 {
15949 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getShaderPrecisionFormat\".");
15950 return false;
15951 }
15952 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15953 Ok(ConversionResult::Success(value)) => value,
15954 Ok(ConversionResult::Failure(error)) => {
15955 throw_type_error(cx.raw_cx(), &error);
15956 return false;
15957
15958 }
15959 _ => {
15960 return false;
15961
15962 },
15963 }
15964 ;
15965 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
15966 Ok(ConversionResult::Success(value)) => value,
15967 Ok(ConversionResult::Failure(error)) => {
15968 throw_type_error(cx.raw_cx(), &error);
15969 return false;
15970
15971 }
15972 _ => {
15973 return false;
15974
15975 },
15976 }
15977 ;
15978 let result: Option<DomRoot<D::WebGLShaderPrecisionFormat>> = this.GetShaderPrecisionFormat(arg0, arg1);
15979
15980 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15981 return true;
15982 })());
15983 result
15984}
15985
15986
15987static getShaderPrecisionFormat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15988
15989pub(crate) fn init_getShaderPrecisionFormat_methodinfo<D: DomTypes>() {
15990 getShaderPrecisionFormat_methodinfo.set(JSJitInfo {
15991 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15992 method: Some(getShaderPrecisionFormat::<D>)
15993 },
15994 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15995 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
15996 },
15997 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15998 _bitfield_align_1: [],
15999 _bitfield_1: __BindgenBitfieldUnit::new(
16000 new_jsjitinfo_bitfield_1!(
16001 JSJitInfo_OpType::Method as u8,
16002 JSJitInfo_AliasSet::AliasEverything as u8,
16003 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
16004 false,
16005 false,
16006 false,
16007 false,
16008 false,
16009 false,
16010 0,
16011 ).to_ne_bytes()
16012 ),
16013});
16014}
16015unsafe extern "C" fn getShaderInfoLog<D: DomTypes>
16016(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16017 let mut result = false;
16018 wrap_panic(&mut || result = (|| {
16019 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16020 let this = &*(this as *const D::WebGL2RenderingContext);
16021 let args = &*args;
16022 let argc = args.argc_;
16023
16024 if argc < 1 {
16025 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getShaderInfoLog\".");
16026 return false;
16027 }
16028 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16029 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16030 Ok(val) => val,
16031 Err(()) => {
16032 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
16033 return false;
16034
16035 }
16036 }
16037
16038 } else {
16039 throw_type_error(cx.raw_cx(), "Value is not an object.");
16040 return false;
16041
16042 };
16043 let result: Option<DOMString> = this.GetShaderInfoLog(&arg0);
16044
16045 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16046 return true;
16047 })());
16048 result
16049}
16050
16051
16052static getShaderInfoLog_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16053
16054pub(crate) fn init_getShaderInfoLog_methodinfo<D: DomTypes>() {
16055 getShaderInfoLog_methodinfo.set(JSJitInfo {
16056 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16057 method: Some(getShaderInfoLog::<D>)
16058 },
16059 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16060 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16061 },
16062 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16063 _bitfield_align_1: [],
16064 _bitfield_1: __BindgenBitfieldUnit::new(
16065 new_jsjitinfo_bitfield_1!(
16066 JSJitInfo_OpType::Method as u8,
16067 JSJitInfo_AliasSet::AliasEverything as u8,
16068 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
16069 false,
16070 false,
16071 false,
16072 false,
16073 false,
16074 false,
16075 0,
16076 ).to_ne_bytes()
16077 ),
16078});
16079}
16080unsafe extern "C" fn getShaderSource<D: DomTypes>
16081(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16082 let mut result = false;
16083 wrap_panic(&mut || result = (|| {
16084 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16085 let this = &*(this as *const D::WebGL2RenderingContext);
16086 let args = &*args;
16087 let argc = args.argc_;
16088
16089 if argc < 1 {
16090 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getShaderSource\".");
16091 return false;
16092 }
16093 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16094 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16095 Ok(val) => val,
16096 Err(()) => {
16097 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
16098 return false;
16099
16100 }
16101 }
16102
16103 } else {
16104 throw_type_error(cx.raw_cx(), "Value is not an object.");
16105 return false;
16106
16107 };
16108 let result: Option<DOMString> = this.GetShaderSource(&arg0);
16109
16110 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16111 return true;
16112 })());
16113 result
16114}
16115
16116
16117static getShaderSource_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16118
16119pub(crate) fn init_getShaderSource_methodinfo<D: DomTypes>() {
16120 getShaderSource_methodinfo.set(JSJitInfo {
16121 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16122 method: Some(getShaderSource::<D>)
16123 },
16124 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16125 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16126 },
16127 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16128 _bitfield_align_1: [],
16129 _bitfield_1: __BindgenBitfieldUnit::new(
16130 new_jsjitinfo_bitfield_1!(
16131 JSJitInfo_OpType::Method as u8,
16132 JSJitInfo_AliasSet::AliasEverything as u8,
16133 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
16134 false,
16135 false,
16136 false,
16137 false,
16138 false,
16139 false,
16140 0,
16141 ).to_ne_bytes()
16142 ),
16143});
16144}
16145unsafe extern "C" fn getTexParameter<D: DomTypes>
16146(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16147 let mut result = false;
16148 wrap_panic(&mut || result = (|| {
16149 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16150 let this = &*(this as *const D::WebGL2RenderingContext);
16151 let args = &*args;
16152 let argc = args.argc_;
16153
16154 if argc < 2 {
16155 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getTexParameter\".");
16156 return false;
16157 }
16158 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16159 Ok(ConversionResult::Success(value)) => value,
16160 Ok(ConversionResult::Failure(error)) => {
16161 throw_type_error(cx.raw_cx(), &error);
16162 return false;
16163
16164 }
16165 _ => {
16166 return false;
16167
16168 },
16169 }
16170 ;
16171 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
16172 Ok(ConversionResult::Success(value)) => value,
16173 Ok(ConversionResult::Failure(error)) => {
16174 throw_type_error(cx.raw_cx(), &error);
16175 return false;
16176
16177 }
16178 _ => {
16179 return false;
16180
16181 },
16182 }
16183 ;
16184 rooted!(&in(cx) let mut retval: JSVal);
16185 let result: () = this.GetTexParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
16186
16187 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16188 return true;
16189 })());
16190 result
16191}
16192
16193
16194static getTexParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16195
16196pub(crate) fn init_getTexParameter_methodinfo<D: DomTypes>() {
16197 getTexParameter_methodinfo.set(JSJitInfo {
16198 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16199 method: Some(getTexParameter::<D>)
16200 },
16201 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16202 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16203 },
16204 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16205 _bitfield_align_1: [],
16206 _bitfield_1: __BindgenBitfieldUnit::new(
16207 new_jsjitinfo_bitfield_1!(
16208 JSJitInfo_OpType::Method as u8,
16209 JSJitInfo_AliasSet::AliasEverything as u8,
16210 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
16211 false,
16212 false,
16213 false,
16214 false,
16215 false,
16216 false,
16217 0,
16218 ).to_ne_bytes()
16219 ),
16220});
16221}
16222unsafe extern "C" fn getUniform<D: DomTypes>
16223(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16224 let mut result = false;
16225 wrap_panic(&mut || result = (|| {
16226 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16227 let this = &*(this as *const D::WebGL2RenderingContext);
16228 let args = &*args;
16229 let argc = args.argc_;
16230
16231 if argc < 2 {
16232 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getUniform\".");
16233 return false;
16234 }
16235 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16236 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16237 Ok(val) => val,
16238 Err(()) => {
16239 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
16240 return false;
16241
16242 }
16243 }
16244
16245 } else {
16246 throw_type_error(cx.raw_cx(), "Value is not an object.");
16247 return false;
16248
16249 };
16250 let arg1: DomRoot<D::WebGLUniformLocation> = if HandleValue::from_raw(args.get(1)).get().is_object() {
16251 match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
16252 Ok(val) => val,
16253 Err(()) => {
16254 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
16255 return false;
16256
16257 }
16258 }
16259
16260 } else {
16261 throw_type_error(cx.raw_cx(), "Value is not an object.");
16262 return false;
16263
16264 };
16265 rooted!(&in(cx) let mut retval: JSVal);
16266 let result: () = this.GetUniform(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, &arg1, retval.handle_mut());
16267
16268 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16269 return true;
16270 })());
16271 result
16272}
16273
16274
16275static getUniform_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16276
16277pub(crate) fn init_getUniform_methodinfo<D: DomTypes>() {
16278 getUniform_methodinfo.set(JSJitInfo {
16279 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16280 method: Some(getUniform::<D>)
16281 },
16282 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16283 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16284 },
16285 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16286 _bitfield_align_1: [],
16287 _bitfield_1: __BindgenBitfieldUnit::new(
16288 new_jsjitinfo_bitfield_1!(
16289 JSJitInfo_OpType::Method as u8,
16290 JSJitInfo_AliasSet::AliasEverything as u8,
16291 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
16292 false,
16293 false,
16294 false,
16295 false,
16296 false,
16297 false,
16298 0,
16299 ).to_ne_bytes()
16300 ),
16301});
16302}
16303unsafe extern "C" fn getUniformLocation<D: DomTypes>
16304(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16305 let mut result = false;
16306 wrap_panic(&mut || result = (|| {
16307 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16308 let this = &*(this as *const D::WebGL2RenderingContext);
16309 let args = &*args;
16310 let argc = args.argc_;
16311
16312 if argc < 2 {
16313 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getUniformLocation\".");
16314 return false;
16315 }
16316 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16317 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16318 Ok(val) => val,
16319 Err(()) => {
16320 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
16321 return false;
16322
16323 }
16324 }
16325
16326 } else {
16327 throw_type_error(cx.raw_cx(), "Value is not an object.");
16328 return false;
16329
16330 };
16331 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
16332 Ok(ConversionResult::Success(value)) => value,
16333 Ok(ConversionResult::Failure(error)) => {
16334 throw_type_error(cx.raw_cx(), &error);
16335 return false;
16336
16337 }
16338 _ => {
16339 return false;
16340
16341 },
16342 }
16343 ;
16344 let result: Option<DomRoot<D::WebGLUniformLocation>> = this.GetUniformLocation(&arg0, arg1);
16345
16346 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16347 return true;
16348 })());
16349 result
16350}
16351
16352
16353static getUniformLocation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16354
16355pub(crate) fn init_getUniformLocation_methodinfo<D: DomTypes>() {
16356 getUniformLocation_methodinfo.set(JSJitInfo {
16357 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16358 method: Some(getUniformLocation::<D>)
16359 },
16360 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16361 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16362 },
16363 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16364 _bitfield_align_1: [],
16365 _bitfield_1: __BindgenBitfieldUnit::new(
16366 new_jsjitinfo_bitfield_1!(
16367 JSJitInfo_OpType::Method as u8,
16368 JSJitInfo_AliasSet::AliasEverything as u8,
16369 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
16370 false,
16371 false,
16372 false,
16373 false,
16374 false,
16375 false,
16376 0,
16377 ).to_ne_bytes()
16378 ),
16379});
16380}
16381unsafe extern "C" fn getVertexAttrib<D: DomTypes>
16382(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16383 let mut result = false;
16384 wrap_panic(&mut || result = (|| {
16385 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16386 let this = &*(this as *const D::WebGL2RenderingContext);
16387 let args = &*args;
16388 let argc = args.argc_;
16389
16390 if argc < 2 {
16391 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getVertexAttrib\".");
16392 return false;
16393 }
16394 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16395 Ok(ConversionResult::Success(value)) => value,
16396 Ok(ConversionResult::Failure(error)) => {
16397 throw_type_error(cx.raw_cx(), &error);
16398 return false;
16399
16400 }
16401 _ => {
16402 return false;
16403
16404 },
16405 }
16406 ;
16407 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
16408 Ok(ConversionResult::Success(value)) => value,
16409 Ok(ConversionResult::Failure(error)) => {
16410 throw_type_error(cx.raw_cx(), &error);
16411 return false;
16412
16413 }
16414 _ => {
16415 return false;
16416
16417 },
16418 }
16419 ;
16420 rooted!(&in(cx) let mut retval: JSVal);
16421 let result: () = this.GetVertexAttrib(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
16422
16423 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16424 return true;
16425 })());
16426 result
16427}
16428
16429
16430static getVertexAttrib_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16431
16432pub(crate) fn init_getVertexAttrib_methodinfo<D: DomTypes>() {
16433 getVertexAttrib_methodinfo.set(JSJitInfo {
16434 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16435 method: Some(getVertexAttrib::<D>)
16436 },
16437 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16438 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16439 },
16440 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16441 _bitfield_align_1: [],
16442 _bitfield_1: __BindgenBitfieldUnit::new(
16443 new_jsjitinfo_bitfield_1!(
16444 JSJitInfo_OpType::Method as u8,
16445 JSJitInfo_AliasSet::AliasEverything as u8,
16446 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
16447 false,
16448 false,
16449 false,
16450 false,
16451 false,
16452 false,
16453 0,
16454 ).to_ne_bytes()
16455 ),
16456});
16457}
16458unsafe extern "C" fn getVertexAttribOffset<D: DomTypes>
16459(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16460 let mut result = false;
16461 wrap_panic(&mut || result = (|| {
16462 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16463 let this = &*(this as *const D::WebGL2RenderingContext);
16464 let args = &*args;
16465 let argc = args.argc_;
16466
16467 if argc < 2 {
16468 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.getVertexAttribOffset\".");
16469 return false;
16470 }
16471 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16472 Ok(ConversionResult::Success(value)) => value,
16473 Ok(ConversionResult::Failure(error)) => {
16474 throw_type_error(cx.raw_cx(), &error);
16475 return false;
16476
16477 }
16478 _ => {
16479 return false;
16480
16481 },
16482 }
16483 ;
16484 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
16485 Ok(ConversionResult::Success(value)) => value,
16486 Ok(ConversionResult::Failure(error)) => {
16487 throw_type_error(cx.raw_cx(), &error);
16488 return false;
16489
16490 }
16491 _ => {
16492 return false;
16493
16494 },
16495 }
16496 ;
16497 let result: i64 = this.GetVertexAttribOffset(arg0, arg1);
16498
16499 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16500 return true;
16501 })());
16502 result
16503}
16504
16505
16506static getVertexAttribOffset_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16507
16508pub(crate) fn init_getVertexAttribOffset_methodinfo<D: DomTypes>() {
16509 getVertexAttribOffset_methodinfo.set(JSJitInfo {
16510 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16511 method: Some(getVertexAttribOffset::<D>)
16512 },
16513 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16514 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16515 },
16516 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16517 _bitfield_align_1: [],
16518 _bitfield_1: __BindgenBitfieldUnit::new(
16519 new_jsjitinfo_bitfield_1!(
16520 JSJitInfo_OpType::Method as u8,
16521 JSJitInfo_AliasSet::AliasEverything as u8,
16522 JSValueType::JSVAL_TYPE_DOUBLE as u8,
16523 false,
16524 false,
16525 false,
16526 false,
16527 false,
16528 false,
16529 0,
16530 ).to_ne_bytes()
16531 ),
16532});
16533}
16534unsafe extern "C" fn hint<D: DomTypes>
16535(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16536 let mut result = false;
16537 wrap_panic(&mut || result = (|| {
16538 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16539 let this = &*(this as *const D::WebGL2RenderingContext);
16540 let args = &*args;
16541 let argc = args.argc_;
16542
16543 if argc < 2 {
16544 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.hint\".");
16545 return false;
16546 }
16547 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16548 Ok(ConversionResult::Success(value)) => value,
16549 Ok(ConversionResult::Failure(error)) => {
16550 throw_type_error(cx.raw_cx(), &error);
16551 return false;
16552
16553 }
16554 _ => {
16555 return false;
16556
16557 },
16558 }
16559 ;
16560 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
16561 Ok(ConversionResult::Success(value)) => value,
16562 Ok(ConversionResult::Failure(error)) => {
16563 throw_type_error(cx.raw_cx(), &error);
16564 return false;
16565
16566 }
16567 _ => {
16568 return false;
16569
16570 },
16571 }
16572 ;
16573 let result: () = this.Hint(arg0, arg1);
16574
16575 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16576 return true;
16577 })());
16578 result
16579}
16580
16581
16582static hint_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16583
16584pub(crate) fn init_hint_methodinfo<D: DomTypes>() {
16585 hint_methodinfo.set(JSJitInfo {
16586 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16587 method: Some(hint::<D>)
16588 },
16589 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16590 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16591 },
16592 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16593 _bitfield_align_1: [],
16594 _bitfield_1: __BindgenBitfieldUnit::new(
16595 new_jsjitinfo_bitfield_1!(
16596 JSJitInfo_OpType::Method as u8,
16597 JSJitInfo_AliasSet::AliasEverything as u8,
16598 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16599 false,
16600 false,
16601 false,
16602 false,
16603 false,
16604 false,
16605 0,
16606 ).to_ne_bytes()
16607 ),
16608});
16609}
16610unsafe extern "C" fn isBuffer<D: DomTypes>
16611(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16612 let mut result = false;
16613 wrap_panic(&mut || result = (|| {
16614 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16615 let this = &*(this as *const D::WebGL2RenderingContext);
16616 let args = &*args;
16617 let argc = args.argc_;
16618
16619 if argc < 1 {
16620 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isBuffer\".");
16621 return false;
16622 }
16623 let arg0: Option<DomRoot<D::WebGLBuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16624 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16625 Ok(val) => val,
16626 Err(()) => {
16627 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLBuffer.");
16628 return false;
16629
16630 }
16631 }
16632 )
16633 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
16634 None
16635 } else {
16636 throw_type_error(cx.raw_cx(), "Value is not an object.");
16637 return false;
16638
16639 };
16640 let result: bool = this.IsBuffer(arg0.as_deref());
16641
16642 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16643 return true;
16644 })());
16645 result
16646}
16647
16648
16649static isBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16650
16651pub(crate) fn init_isBuffer_methodinfo<D: DomTypes>() {
16652 isBuffer_methodinfo.set(JSJitInfo {
16653 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16654 method: Some(isBuffer::<D>)
16655 },
16656 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16657 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16658 },
16659 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16660 _bitfield_align_1: [],
16661 _bitfield_1: __BindgenBitfieldUnit::new(
16662 new_jsjitinfo_bitfield_1!(
16663 JSJitInfo_OpType::Method as u8,
16664 JSJitInfo_AliasSet::AliasEverything as u8,
16665 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
16666 false,
16667 false,
16668 false,
16669 false,
16670 false,
16671 false,
16672 0,
16673 ).to_ne_bytes()
16674 ),
16675});
16676}
16677unsafe extern "C" fn isEnabled<D: DomTypes>
16678(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16679 let mut result = false;
16680 wrap_panic(&mut || result = (|| {
16681 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16682 let this = &*(this as *const D::WebGL2RenderingContext);
16683 let args = &*args;
16684 let argc = args.argc_;
16685
16686 if argc < 1 {
16687 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isEnabled\".");
16688 return false;
16689 }
16690 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16691 Ok(ConversionResult::Success(value)) => value,
16692 Ok(ConversionResult::Failure(error)) => {
16693 throw_type_error(cx.raw_cx(), &error);
16694 return false;
16695
16696 }
16697 _ => {
16698 return false;
16699
16700 },
16701 }
16702 ;
16703 let result: bool = this.IsEnabled(arg0);
16704
16705 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16706 return true;
16707 })());
16708 result
16709}
16710
16711
16712static isEnabled_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16713
16714pub(crate) fn init_isEnabled_methodinfo<D: DomTypes>() {
16715 isEnabled_methodinfo.set(JSJitInfo {
16716 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16717 method: Some(isEnabled::<D>)
16718 },
16719 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16720 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16721 },
16722 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16723 _bitfield_align_1: [],
16724 _bitfield_1: __BindgenBitfieldUnit::new(
16725 new_jsjitinfo_bitfield_1!(
16726 JSJitInfo_OpType::Method as u8,
16727 JSJitInfo_AliasSet::AliasEverything as u8,
16728 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
16729 false,
16730 false,
16731 false,
16732 false,
16733 false,
16734 false,
16735 0,
16736 ).to_ne_bytes()
16737 ),
16738});
16739}
16740unsafe extern "C" fn isFramebuffer<D: DomTypes>
16741(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16742 let mut result = false;
16743 wrap_panic(&mut || result = (|| {
16744 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16745 let this = &*(this as *const D::WebGL2RenderingContext);
16746 let args = &*args;
16747 let argc = args.argc_;
16748
16749 if argc < 1 {
16750 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isFramebuffer\".");
16751 return false;
16752 }
16753 let arg0: Option<DomRoot<D::WebGLFramebuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16754 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16755 Ok(val) => val,
16756 Err(()) => {
16757 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLFramebuffer.");
16758 return false;
16759
16760 }
16761 }
16762 )
16763 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
16764 None
16765 } else {
16766 throw_type_error(cx.raw_cx(), "Value is not an object.");
16767 return false;
16768
16769 };
16770 let result: bool = this.IsFramebuffer(arg0.as_deref());
16771
16772 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16773 return true;
16774 })());
16775 result
16776}
16777
16778
16779static isFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16780
16781pub(crate) fn init_isFramebuffer_methodinfo<D: DomTypes>() {
16782 isFramebuffer_methodinfo.set(JSJitInfo {
16783 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16784 method: Some(isFramebuffer::<D>)
16785 },
16786 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16787 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16788 },
16789 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16790 _bitfield_align_1: [],
16791 _bitfield_1: __BindgenBitfieldUnit::new(
16792 new_jsjitinfo_bitfield_1!(
16793 JSJitInfo_OpType::Method as u8,
16794 JSJitInfo_AliasSet::AliasEverything as u8,
16795 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
16796 false,
16797 false,
16798 false,
16799 false,
16800 false,
16801 false,
16802 0,
16803 ).to_ne_bytes()
16804 ),
16805});
16806}
16807unsafe extern "C" fn isProgram<D: DomTypes>
16808(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16809 let mut result = false;
16810 wrap_panic(&mut || result = (|| {
16811 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16812 let this = &*(this as *const D::WebGL2RenderingContext);
16813 let args = &*args;
16814 let argc = args.argc_;
16815
16816 if argc < 1 {
16817 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isProgram\".");
16818 return false;
16819 }
16820 let arg0: Option<DomRoot<D::WebGLProgram>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16821 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16822 Ok(val) => val,
16823 Err(()) => {
16824 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
16825 return false;
16826
16827 }
16828 }
16829 )
16830 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
16831 None
16832 } else {
16833 throw_type_error(cx.raw_cx(), "Value is not an object.");
16834 return false;
16835
16836 };
16837 let result: bool = this.IsProgram(arg0.as_deref());
16838
16839 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16840 return true;
16841 })());
16842 result
16843}
16844
16845
16846static isProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16847
16848pub(crate) fn init_isProgram_methodinfo<D: DomTypes>() {
16849 isProgram_methodinfo.set(JSJitInfo {
16850 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16851 method: Some(isProgram::<D>)
16852 },
16853 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16854 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16855 },
16856 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16857 _bitfield_align_1: [],
16858 _bitfield_1: __BindgenBitfieldUnit::new(
16859 new_jsjitinfo_bitfield_1!(
16860 JSJitInfo_OpType::Method as u8,
16861 JSJitInfo_AliasSet::AliasEverything as u8,
16862 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
16863 false,
16864 false,
16865 false,
16866 false,
16867 false,
16868 false,
16869 0,
16870 ).to_ne_bytes()
16871 ),
16872});
16873}
16874unsafe extern "C" fn isRenderbuffer<D: DomTypes>
16875(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16876 let mut result = false;
16877 wrap_panic(&mut || result = (|| {
16878 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16879 let this = &*(this as *const D::WebGL2RenderingContext);
16880 let args = &*args;
16881 let argc = args.argc_;
16882
16883 if argc < 1 {
16884 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isRenderbuffer\".");
16885 return false;
16886 }
16887 let arg0: Option<DomRoot<D::WebGLRenderbuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16888 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16889 Ok(val) => val,
16890 Err(()) => {
16891 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLRenderbuffer.");
16892 return false;
16893
16894 }
16895 }
16896 )
16897 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
16898 None
16899 } else {
16900 throw_type_error(cx.raw_cx(), "Value is not an object.");
16901 return false;
16902
16903 };
16904 let result: bool = this.IsRenderbuffer(arg0.as_deref());
16905
16906 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16907 return true;
16908 })());
16909 result
16910}
16911
16912
16913static isRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16914
16915pub(crate) fn init_isRenderbuffer_methodinfo<D: DomTypes>() {
16916 isRenderbuffer_methodinfo.set(JSJitInfo {
16917 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16918 method: Some(isRenderbuffer::<D>)
16919 },
16920 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16921 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16922 },
16923 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16924 _bitfield_align_1: [],
16925 _bitfield_1: __BindgenBitfieldUnit::new(
16926 new_jsjitinfo_bitfield_1!(
16927 JSJitInfo_OpType::Method as u8,
16928 JSJitInfo_AliasSet::AliasEverything as u8,
16929 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
16930 false,
16931 false,
16932 false,
16933 false,
16934 false,
16935 false,
16936 0,
16937 ).to_ne_bytes()
16938 ),
16939});
16940}
16941unsafe extern "C" fn isShader<D: DomTypes>
16942(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16943 let mut result = false;
16944 wrap_panic(&mut || result = (|| {
16945 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16946 let this = &*(this as *const D::WebGL2RenderingContext);
16947 let args = &*args;
16948 let argc = args.argc_;
16949
16950 if argc < 1 {
16951 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isShader\".");
16952 return false;
16953 }
16954 let arg0: Option<DomRoot<D::WebGLShader>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
16955 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16956 Ok(val) => val,
16957 Err(()) => {
16958 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
16959 return false;
16960
16961 }
16962 }
16963 )
16964 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
16965 None
16966 } else {
16967 throw_type_error(cx.raw_cx(), "Value is not an object.");
16968 return false;
16969
16970 };
16971 let result: bool = this.IsShader(arg0.as_deref());
16972
16973 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16974 return true;
16975 })());
16976 result
16977}
16978
16979
16980static isShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16981
16982pub(crate) fn init_isShader_methodinfo<D: DomTypes>() {
16983 isShader_methodinfo.set(JSJitInfo {
16984 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16985 method: Some(isShader::<D>)
16986 },
16987 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16988 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
16989 },
16990 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16991 _bitfield_align_1: [],
16992 _bitfield_1: __BindgenBitfieldUnit::new(
16993 new_jsjitinfo_bitfield_1!(
16994 JSJitInfo_OpType::Method as u8,
16995 JSJitInfo_AliasSet::AliasEverything as u8,
16996 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
16997 false,
16998 false,
16999 false,
17000 false,
17001 false,
17002 false,
17003 0,
17004 ).to_ne_bytes()
17005 ),
17006});
17007}
17008unsafe extern "C" fn isTexture<D: DomTypes>
17009(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17010 let mut result = false;
17011 wrap_panic(&mut || result = (|| {
17012 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17013 let this = &*(this as *const D::WebGL2RenderingContext);
17014 let args = &*args;
17015 let argc = args.argc_;
17016
17017 if argc < 1 {
17018 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.isTexture\".");
17019 return false;
17020 }
17021 let arg0: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
17022 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
17023 Ok(val) => val,
17024 Err(()) => {
17025 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
17026 return false;
17027
17028 }
17029 }
17030 )
17031 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
17032 None
17033 } else {
17034 throw_type_error(cx.raw_cx(), "Value is not an object.");
17035 return false;
17036
17037 };
17038 let result: bool = this.IsTexture(arg0.as_deref());
17039
17040 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17041 return true;
17042 })());
17043 result
17044}
17045
17046
17047static isTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17048
17049pub(crate) fn init_isTexture_methodinfo<D: DomTypes>() {
17050 isTexture_methodinfo.set(JSJitInfo {
17051 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17052 method: Some(isTexture::<D>)
17053 },
17054 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17055 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17056 },
17057 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17058 _bitfield_align_1: [],
17059 _bitfield_1: __BindgenBitfieldUnit::new(
17060 new_jsjitinfo_bitfield_1!(
17061 JSJitInfo_OpType::Method as u8,
17062 JSJitInfo_AliasSet::AliasEverything as u8,
17063 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
17064 false,
17065 false,
17066 false,
17067 false,
17068 false,
17069 false,
17070 0,
17071 ).to_ne_bytes()
17072 ),
17073});
17074}
17075unsafe extern "C" fn lineWidth<D: DomTypes>
17076(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17077 let mut result = false;
17078 wrap_panic(&mut || result = (|| {
17079 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17080 let this = &*(this as *const D::WebGL2RenderingContext);
17081 let args = &*args;
17082 let argc = args.argc_;
17083
17084 if argc < 1 {
17085 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.lineWidth\".");
17086 return false;
17087 }
17088 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
17089 Ok(ConversionResult::Success(value)) => value,
17090 Ok(ConversionResult::Failure(error)) => {
17091 throw_type_error(cx.raw_cx(), &error);
17092 return false;
17093
17094 }
17095 _ => {
17096 return false;
17097
17098 },
17099 }
17100 ;
17101 let result: () = this.LineWidth(arg0);
17102
17103 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17104 return true;
17105 })());
17106 result
17107}
17108
17109
17110static lineWidth_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17111
17112pub(crate) fn init_lineWidth_methodinfo<D: DomTypes>() {
17113 lineWidth_methodinfo.set(JSJitInfo {
17114 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17115 method: Some(lineWidth::<D>)
17116 },
17117 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17118 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17119 },
17120 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17121 _bitfield_align_1: [],
17122 _bitfield_1: __BindgenBitfieldUnit::new(
17123 new_jsjitinfo_bitfield_1!(
17124 JSJitInfo_OpType::Method as u8,
17125 JSJitInfo_AliasSet::AliasEverything as u8,
17126 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17127 false,
17128 false,
17129 false,
17130 false,
17131 false,
17132 false,
17133 0,
17134 ).to_ne_bytes()
17135 ),
17136});
17137}
17138unsafe extern "C" fn linkProgram<D: DomTypes>
17139(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17140 let mut result = false;
17141 wrap_panic(&mut || result = (|| {
17142 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17143 let this = &*(this as *const D::WebGL2RenderingContext);
17144 let args = &*args;
17145 let argc = args.argc_;
17146
17147 if argc < 1 {
17148 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.linkProgram\".");
17149 return false;
17150 }
17151 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
17152 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
17153 Ok(val) => val,
17154 Err(()) => {
17155 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
17156 return false;
17157
17158 }
17159 }
17160
17161 } else {
17162 throw_type_error(cx.raw_cx(), "Value is not an object.");
17163 return false;
17164
17165 };
17166 let result: () = this.LinkProgram(&arg0);
17167
17168 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17169 return true;
17170 })());
17171 result
17172}
17173
17174
17175static linkProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17176
17177pub(crate) fn init_linkProgram_methodinfo<D: DomTypes>() {
17178 linkProgram_methodinfo.set(JSJitInfo {
17179 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17180 method: Some(linkProgram::<D>)
17181 },
17182 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17183 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17184 },
17185 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17186 _bitfield_align_1: [],
17187 _bitfield_1: __BindgenBitfieldUnit::new(
17188 new_jsjitinfo_bitfield_1!(
17189 JSJitInfo_OpType::Method as u8,
17190 JSJitInfo_AliasSet::AliasEverything as u8,
17191 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17192 false,
17193 false,
17194 false,
17195 false,
17196 false,
17197 false,
17198 0,
17199 ).to_ne_bytes()
17200 ),
17201});
17202}
17203unsafe extern "C" fn pixelStorei<D: DomTypes>
17204(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17205 let mut result = false;
17206 wrap_panic(&mut || result = (|| {
17207 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17208 let this = &*(this as *const D::WebGL2RenderingContext);
17209 let args = &*args;
17210 let argc = args.argc_;
17211
17212 if argc < 2 {
17213 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.pixelStorei\".");
17214 return false;
17215 }
17216 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17217 Ok(ConversionResult::Success(value)) => value,
17218 Ok(ConversionResult::Failure(error)) => {
17219 throw_type_error(cx.raw_cx(), &error);
17220 return false;
17221
17222 }
17223 _ => {
17224 return false;
17225
17226 },
17227 }
17228 ;
17229 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
17230 Ok(ConversionResult::Success(value)) => value,
17231 Ok(ConversionResult::Failure(error)) => {
17232 throw_type_error(cx.raw_cx(), &error);
17233 return false;
17234
17235 }
17236 _ => {
17237 return false;
17238
17239 },
17240 }
17241 ;
17242 let result: () = this.PixelStorei(arg0, arg1);
17243
17244 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17245 return true;
17246 })());
17247 result
17248}
17249
17250
17251static pixelStorei_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17252
17253pub(crate) fn init_pixelStorei_methodinfo<D: DomTypes>() {
17254 pixelStorei_methodinfo.set(JSJitInfo {
17255 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17256 method: Some(pixelStorei::<D>)
17257 },
17258 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17259 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17260 },
17261 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17262 _bitfield_align_1: [],
17263 _bitfield_1: __BindgenBitfieldUnit::new(
17264 new_jsjitinfo_bitfield_1!(
17265 JSJitInfo_OpType::Method as u8,
17266 JSJitInfo_AliasSet::AliasEverything as u8,
17267 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17268 false,
17269 false,
17270 false,
17271 false,
17272 false,
17273 false,
17274 0,
17275 ).to_ne_bytes()
17276 ),
17277});
17278}
17279unsafe extern "C" fn polygonOffset<D: DomTypes>
17280(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17281 let mut result = false;
17282 wrap_panic(&mut || result = (|| {
17283 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17284 let this = &*(this as *const D::WebGL2RenderingContext);
17285 let args = &*args;
17286 let argc = args.argc_;
17287
17288 if argc < 2 {
17289 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.polygonOffset\".");
17290 return false;
17291 }
17292 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
17293 Ok(ConversionResult::Success(value)) => value,
17294 Ok(ConversionResult::Failure(error)) => {
17295 throw_type_error(cx.raw_cx(), &error);
17296 return false;
17297
17298 }
17299 _ => {
17300 return false;
17301
17302 },
17303 }
17304 ;
17305 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
17306 Ok(ConversionResult::Success(value)) => value,
17307 Ok(ConversionResult::Failure(error)) => {
17308 throw_type_error(cx.raw_cx(), &error);
17309 return false;
17310
17311 }
17312 _ => {
17313 return false;
17314
17315 },
17316 }
17317 ;
17318 let result: () = this.PolygonOffset(arg0, arg1);
17319
17320 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17321 return true;
17322 })());
17323 result
17324}
17325
17326
17327static polygonOffset_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17328
17329pub(crate) fn init_polygonOffset_methodinfo<D: DomTypes>() {
17330 polygonOffset_methodinfo.set(JSJitInfo {
17331 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17332 method: Some(polygonOffset::<D>)
17333 },
17334 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17335 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17336 },
17337 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17338 _bitfield_align_1: [],
17339 _bitfield_1: __BindgenBitfieldUnit::new(
17340 new_jsjitinfo_bitfield_1!(
17341 JSJitInfo_OpType::Method as u8,
17342 JSJitInfo_AliasSet::AliasEverything as u8,
17343 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17344 false,
17345 false,
17346 false,
17347 false,
17348 false,
17349 false,
17350 0,
17351 ).to_ne_bytes()
17352 ),
17353});
17354}
17355unsafe extern "C" fn renderbufferStorage<D: DomTypes>
17356(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17357 let mut result = false;
17358 wrap_panic(&mut || result = (|| {
17359 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17360 let this = &*(this as *const D::WebGL2RenderingContext);
17361 let args = &*args;
17362 let argc = args.argc_;
17363
17364 if argc < 4 {
17365 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.renderbufferStorage\".");
17366 return false;
17367 }
17368 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17369 Ok(ConversionResult::Success(value)) => value,
17370 Ok(ConversionResult::Failure(error)) => {
17371 throw_type_error(cx.raw_cx(), &error);
17372 return false;
17373
17374 }
17375 _ => {
17376 return false;
17377
17378 },
17379 }
17380 ;
17381 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
17382 Ok(ConversionResult::Success(value)) => value,
17383 Ok(ConversionResult::Failure(error)) => {
17384 throw_type_error(cx.raw_cx(), &error);
17385 return false;
17386
17387 }
17388 _ => {
17389 return false;
17390
17391 },
17392 }
17393 ;
17394 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
17395 Ok(ConversionResult::Success(value)) => value,
17396 Ok(ConversionResult::Failure(error)) => {
17397 throw_type_error(cx.raw_cx(), &error);
17398 return false;
17399
17400 }
17401 _ => {
17402 return false;
17403
17404 },
17405 }
17406 ;
17407 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
17408 Ok(ConversionResult::Success(value)) => value,
17409 Ok(ConversionResult::Failure(error)) => {
17410 throw_type_error(cx.raw_cx(), &error);
17411 return false;
17412
17413 }
17414 _ => {
17415 return false;
17416
17417 },
17418 }
17419 ;
17420 let result: () = this.RenderbufferStorage(arg0, arg1, arg2, arg3);
17421
17422 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17423 return true;
17424 })());
17425 result
17426}
17427
17428
17429static renderbufferStorage_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17430
17431pub(crate) fn init_renderbufferStorage_methodinfo<D: DomTypes>() {
17432 renderbufferStorage_methodinfo.set(JSJitInfo {
17433 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17434 method: Some(renderbufferStorage::<D>)
17435 },
17436 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17437 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17438 },
17439 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17440 _bitfield_align_1: [],
17441 _bitfield_1: __BindgenBitfieldUnit::new(
17442 new_jsjitinfo_bitfield_1!(
17443 JSJitInfo_OpType::Method as u8,
17444 JSJitInfo_AliasSet::AliasEverything as u8,
17445 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17446 false,
17447 false,
17448 false,
17449 false,
17450 false,
17451 false,
17452 0,
17453 ).to_ne_bytes()
17454 ),
17455});
17456}
17457unsafe extern "C" fn sampleCoverage<D: DomTypes>
17458(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17459 let mut result = false;
17460 wrap_panic(&mut || result = (|| {
17461 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17462 let this = &*(this as *const D::WebGL2RenderingContext);
17463 let args = &*args;
17464 let argc = args.argc_;
17465
17466 if argc < 2 {
17467 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.sampleCoverage\".");
17468 return false;
17469 }
17470 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
17471 Ok(ConversionResult::Success(value)) => value,
17472 Ok(ConversionResult::Failure(error)) => {
17473 throw_type_error(cx.raw_cx(), &error);
17474 return false;
17475
17476 }
17477 _ => {
17478 return false;
17479
17480 },
17481 }
17482 ;
17483 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
17484 Ok(ConversionResult::Success(value)) => value,
17485 Ok(ConversionResult::Failure(error)) => {
17486 throw_type_error(cx.raw_cx(), &error);
17487 return false;
17488
17489 }
17490 _ => {
17491 return false;
17492
17493 },
17494 }
17495 ;
17496 let result: () = this.SampleCoverage(arg0, arg1);
17497
17498 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17499 return true;
17500 })());
17501 result
17502}
17503
17504
17505static sampleCoverage_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17506
17507pub(crate) fn init_sampleCoverage_methodinfo<D: DomTypes>() {
17508 sampleCoverage_methodinfo.set(JSJitInfo {
17509 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17510 method: Some(sampleCoverage::<D>)
17511 },
17512 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17513 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17514 },
17515 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17516 _bitfield_align_1: [],
17517 _bitfield_1: __BindgenBitfieldUnit::new(
17518 new_jsjitinfo_bitfield_1!(
17519 JSJitInfo_OpType::Method as u8,
17520 JSJitInfo_AliasSet::AliasEverything as u8,
17521 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17522 false,
17523 false,
17524 false,
17525 false,
17526 false,
17527 false,
17528 0,
17529 ).to_ne_bytes()
17530 ),
17531});
17532}
17533unsafe extern "C" fn scissor<D: DomTypes>
17534(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17535 let mut result = false;
17536 wrap_panic(&mut || result = (|| {
17537 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17538 let this = &*(this as *const D::WebGL2RenderingContext);
17539 let args = &*args;
17540 let argc = args.argc_;
17541
17542 if argc < 4 {
17543 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.scissor\".");
17544 return false;
17545 }
17546 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17547 Ok(ConversionResult::Success(value)) => value,
17548 Ok(ConversionResult::Failure(error)) => {
17549 throw_type_error(cx.raw_cx(), &error);
17550 return false;
17551
17552 }
17553 _ => {
17554 return false;
17555
17556 },
17557 }
17558 ;
17559 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
17560 Ok(ConversionResult::Success(value)) => value,
17561 Ok(ConversionResult::Failure(error)) => {
17562 throw_type_error(cx.raw_cx(), &error);
17563 return false;
17564
17565 }
17566 _ => {
17567 return false;
17568
17569 },
17570 }
17571 ;
17572 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
17573 Ok(ConversionResult::Success(value)) => value,
17574 Ok(ConversionResult::Failure(error)) => {
17575 throw_type_error(cx.raw_cx(), &error);
17576 return false;
17577
17578 }
17579 _ => {
17580 return false;
17581
17582 },
17583 }
17584 ;
17585 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
17586 Ok(ConversionResult::Success(value)) => value,
17587 Ok(ConversionResult::Failure(error)) => {
17588 throw_type_error(cx.raw_cx(), &error);
17589 return false;
17590
17591 }
17592 _ => {
17593 return false;
17594
17595 },
17596 }
17597 ;
17598 let result: () = this.Scissor(arg0, arg1, arg2, arg3);
17599
17600 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17601 return true;
17602 })());
17603 result
17604}
17605
17606
17607static scissor_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17608
17609pub(crate) fn init_scissor_methodinfo<D: DomTypes>() {
17610 scissor_methodinfo.set(JSJitInfo {
17611 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17612 method: Some(scissor::<D>)
17613 },
17614 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17615 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17616 },
17617 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17618 _bitfield_align_1: [],
17619 _bitfield_1: __BindgenBitfieldUnit::new(
17620 new_jsjitinfo_bitfield_1!(
17621 JSJitInfo_OpType::Method as u8,
17622 JSJitInfo_AliasSet::AliasEverything as u8,
17623 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17624 false,
17625 false,
17626 false,
17627 false,
17628 false,
17629 false,
17630 0,
17631 ).to_ne_bytes()
17632 ),
17633});
17634}
17635unsafe extern "C" fn shaderSource<D: DomTypes>
17636(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17637 let mut result = false;
17638 wrap_panic(&mut || result = (|| {
17639 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17640 let this = &*(this as *const D::WebGL2RenderingContext);
17641 let args = &*args;
17642 let argc = args.argc_;
17643
17644 if argc < 2 {
17645 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.shaderSource\".");
17646 return false;
17647 }
17648 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
17649 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
17650 Ok(val) => val,
17651 Err(()) => {
17652 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
17653 return false;
17654
17655 }
17656 }
17657
17658 } else {
17659 throw_type_error(cx.raw_cx(), "Value is not an object.");
17660 return false;
17661
17662 };
17663 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
17664 Ok(ConversionResult::Success(value)) => value,
17665 Ok(ConversionResult::Failure(error)) => {
17666 throw_type_error(cx.raw_cx(), &error);
17667 return false;
17668
17669 }
17670 _ => {
17671 return false;
17672
17673 },
17674 }
17675 ;
17676 let result: () = this.ShaderSource(&arg0, arg1);
17677
17678 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17679 return true;
17680 })());
17681 result
17682}
17683
17684
17685static shaderSource_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17686
17687pub(crate) fn init_shaderSource_methodinfo<D: DomTypes>() {
17688 shaderSource_methodinfo.set(JSJitInfo {
17689 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17690 method: Some(shaderSource::<D>)
17691 },
17692 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17693 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17694 },
17695 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17696 _bitfield_align_1: [],
17697 _bitfield_1: __BindgenBitfieldUnit::new(
17698 new_jsjitinfo_bitfield_1!(
17699 JSJitInfo_OpType::Method as u8,
17700 JSJitInfo_AliasSet::AliasEverything as u8,
17701 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17702 false,
17703 false,
17704 false,
17705 false,
17706 false,
17707 false,
17708 0,
17709 ).to_ne_bytes()
17710 ),
17711});
17712}
17713unsafe extern "C" fn stencilFunc<D: DomTypes>
17714(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17715 let mut result = false;
17716 wrap_panic(&mut || result = (|| {
17717 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17718 let this = &*(this as *const D::WebGL2RenderingContext);
17719 let args = &*args;
17720 let argc = args.argc_;
17721
17722 if argc < 3 {
17723 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.stencilFunc\".");
17724 return false;
17725 }
17726 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17727 Ok(ConversionResult::Success(value)) => value,
17728 Ok(ConversionResult::Failure(error)) => {
17729 throw_type_error(cx.raw_cx(), &error);
17730 return false;
17731
17732 }
17733 _ => {
17734 return false;
17735
17736 },
17737 }
17738 ;
17739 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
17740 Ok(ConversionResult::Success(value)) => value,
17741 Ok(ConversionResult::Failure(error)) => {
17742 throw_type_error(cx.raw_cx(), &error);
17743 return false;
17744
17745 }
17746 _ => {
17747 return false;
17748
17749 },
17750 }
17751 ;
17752 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
17753 Ok(ConversionResult::Success(value)) => value,
17754 Ok(ConversionResult::Failure(error)) => {
17755 throw_type_error(cx.raw_cx(), &error);
17756 return false;
17757
17758 }
17759 _ => {
17760 return false;
17761
17762 },
17763 }
17764 ;
17765 let result: () = this.StencilFunc(arg0, arg1, arg2);
17766
17767 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17768 return true;
17769 })());
17770 result
17771}
17772
17773
17774static stencilFunc_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17775
17776pub(crate) fn init_stencilFunc_methodinfo<D: DomTypes>() {
17777 stencilFunc_methodinfo.set(JSJitInfo {
17778 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17779 method: Some(stencilFunc::<D>)
17780 },
17781 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17782 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17783 },
17784 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17785 _bitfield_align_1: [],
17786 _bitfield_1: __BindgenBitfieldUnit::new(
17787 new_jsjitinfo_bitfield_1!(
17788 JSJitInfo_OpType::Method as u8,
17789 JSJitInfo_AliasSet::AliasEverything as u8,
17790 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17791 false,
17792 false,
17793 false,
17794 false,
17795 false,
17796 false,
17797 0,
17798 ).to_ne_bytes()
17799 ),
17800});
17801}
17802unsafe extern "C" fn stencilFuncSeparate<D: DomTypes>
17803(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17804 let mut result = false;
17805 wrap_panic(&mut || result = (|| {
17806 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17807 let this = &*(this as *const D::WebGL2RenderingContext);
17808 let args = &*args;
17809 let argc = args.argc_;
17810
17811 if argc < 4 {
17812 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.stencilFuncSeparate\".");
17813 return false;
17814 }
17815 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17816 Ok(ConversionResult::Success(value)) => value,
17817 Ok(ConversionResult::Failure(error)) => {
17818 throw_type_error(cx.raw_cx(), &error);
17819 return false;
17820
17821 }
17822 _ => {
17823 return false;
17824
17825 },
17826 }
17827 ;
17828 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
17829 Ok(ConversionResult::Success(value)) => value,
17830 Ok(ConversionResult::Failure(error)) => {
17831 throw_type_error(cx.raw_cx(), &error);
17832 return false;
17833
17834 }
17835 _ => {
17836 return false;
17837
17838 },
17839 }
17840 ;
17841 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
17842 Ok(ConversionResult::Success(value)) => value,
17843 Ok(ConversionResult::Failure(error)) => {
17844 throw_type_error(cx.raw_cx(), &error);
17845 return false;
17846
17847 }
17848 _ => {
17849 return false;
17850
17851 },
17852 }
17853 ;
17854 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
17855 Ok(ConversionResult::Success(value)) => value,
17856 Ok(ConversionResult::Failure(error)) => {
17857 throw_type_error(cx.raw_cx(), &error);
17858 return false;
17859
17860 }
17861 _ => {
17862 return false;
17863
17864 },
17865 }
17866 ;
17867 let result: () = this.StencilFuncSeparate(arg0, arg1, arg2, arg3);
17868
17869 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17870 return true;
17871 })());
17872 result
17873}
17874
17875
17876static stencilFuncSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17877
17878pub(crate) fn init_stencilFuncSeparate_methodinfo<D: DomTypes>() {
17879 stencilFuncSeparate_methodinfo.set(JSJitInfo {
17880 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17881 method: Some(stencilFuncSeparate::<D>)
17882 },
17883 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17884 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17885 },
17886 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17887 _bitfield_align_1: [],
17888 _bitfield_1: __BindgenBitfieldUnit::new(
17889 new_jsjitinfo_bitfield_1!(
17890 JSJitInfo_OpType::Method as u8,
17891 JSJitInfo_AliasSet::AliasEverything as u8,
17892 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17893 false,
17894 false,
17895 false,
17896 false,
17897 false,
17898 false,
17899 0,
17900 ).to_ne_bytes()
17901 ),
17902});
17903}
17904unsafe extern "C" fn stencilMask<D: DomTypes>
17905(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17906 let mut result = false;
17907 wrap_panic(&mut || result = (|| {
17908 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17909 let this = &*(this as *const D::WebGL2RenderingContext);
17910 let args = &*args;
17911 let argc = args.argc_;
17912
17913 if argc < 1 {
17914 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.stencilMask\".");
17915 return false;
17916 }
17917 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17918 Ok(ConversionResult::Success(value)) => value,
17919 Ok(ConversionResult::Failure(error)) => {
17920 throw_type_error(cx.raw_cx(), &error);
17921 return false;
17922
17923 }
17924 _ => {
17925 return false;
17926
17927 },
17928 }
17929 ;
17930 let result: () = this.StencilMask(arg0);
17931
17932 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17933 return true;
17934 })());
17935 result
17936}
17937
17938
17939static stencilMask_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17940
17941pub(crate) fn init_stencilMask_methodinfo<D: DomTypes>() {
17942 stencilMask_methodinfo.set(JSJitInfo {
17943 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17944 method: Some(stencilMask::<D>)
17945 },
17946 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17947 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
17948 },
17949 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17950 _bitfield_align_1: [],
17951 _bitfield_1: __BindgenBitfieldUnit::new(
17952 new_jsjitinfo_bitfield_1!(
17953 JSJitInfo_OpType::Method as u8,
17954 JSJitInfo_AliasSet::AliasEverything as u8,
17955 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17956 false,
17957 false,
17958 false,
17959 false,
17960 false,
17961 false,
17962 0,
17963 ).to_ne_bytes()
17964 ),
17965});
17966}
17967unsafe extern "C" fn stencilMaskSeparate<D: DomTypes>
17968(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17969 let mut result = false;
17970 wrap_panic(&mut || result = (|| {
17971 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17972 let this = &*(this as *const D::WebGL2RenderingContext);
17973 let args = &*args;
17974 let argc = args.argc_;
17975
17976 if argc < 2 {
17977 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.stencilMaskSeparate\".");
17978 return false;
17979 }
17980 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17981 Ok(ConversionResult::Success(value)) => value,
17982 Ok(ConversionResult::Failure(error)) => {
17983 throw_type_error(cx.raw_cx(), &error);
17984 return false;
17985
17986 }
17987 _ => {
17988 return false;
17989
17990 },
17991 }
17992 ;
17993 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
17994 Ok(ConversionResult::Success(value)) => value,
17995 Ok(ConversionResult::Failure(error)) => {
17996 throw_type_error(cx.raw_cx(), &error);
17997 return false;
17998
17999 }
18000 _ => {
18001 return false;
18002
18003 },
18004 }
18005 ;
18006 let result: () = this.StencilMaskSeparate(arg0, arg1);
18007
18008 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18009 return true;
18010 })());
18011 result
18012}
18013
18014
18015static stencilMaskSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18016
18017pub(crate) fn init_stencilMaskSeparate_methodinfo<D: DomTypes>() {
18018 stencilMaskSeparate_methodinfo.set(JSJitInfo {
18019 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18020 method: Some(stencilMaskSeparate::<D>)
18021 },
18022 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18023 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18024 },
18025 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18026 _bitfield_align_1: [],
18027 _bitfield_1: __BindgenBitfieldUnit::new(
18028 new_jsjitinfo_bitfield_1!(
18029 JSJitInfo_OpType::Method as u8,
18030 JSJitInfo_AliasSet::AliasEverything as u8,
18031 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18032 false,
18033 false,
18034 false,
18035 false,
18036 false,
18037 false,
18038 0,
18039 ).to_ne_bytes()
18040 ),
18041});
18042}
18043unsafe extern "C" fn stencilOp<D: DomTypes>
18044(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18045 let mut result = false;
18046 wrap_panic(&mut || result = (|| {
18047 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18048 let this = &*(this as *const D::WebGL2RenderingContext);
18049 let args = &*args;
18050 let argc = args.argc_;
18051
18052 if argc < 3 {
18053 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.stencilOp\".");
18054 return false;
18055 }
18056 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
18057 Ok(ConversionResult::Success(value)) => value,
18058 Ok(ConversionResult::Failure(error)) => {
18059 throw_type_error(cx.raw_cx(), &error);
18060 return false;
18061
18062 }
18063 _ => {
18064 return false;
18065
18066 },
18067 }
18068 ;
18069 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
18070 Ok(ConversionResult::Success(value)) => value,
18071 Ok(ConversionResult::Failure(error)) => {
18072 throw_type_error(cx.raw_cx(), &error);
18073 return false;
18074
18075 }
18076 _ => {
18077 return false;
18078
18079 },
18080 }
18081 ;
18082 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
18083 Ok(ConversionResult::Success(value)) => value,
18084 Ok(ConversionResult::Failure(error)) => {
18085 throw_type_error(cx.raw_cx(), &error);
18086 return false;
18087
18088 }
18089 _ => {
18090 return false;
18091
18092 },
18093 }
18094 ;
18095 let result: () = this.StencilOp(arg0, arg1, arg2);
18096
18097 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18098 return true;
18099 })());
18100 result
18101}
18102
18103
18104static stencilOp_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18105
18106pub(crate) fn init_stencilOp_methodinfo<D: DomTypes>() {
18107 stencilOp_methodinfo.set(JSJitInfo {
18108 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18109 method: Some(stencilOp::<D>)
18110 },
18111 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18112 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18113 },
18114 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18115 _bitfield_align_1: [],
18116 _bitfield_1: __BindgenBitfieldUnit::new(
18117 new_jsjitinfo_bitfield_1!(
18118 JSJitInfo_OpType::Method as u8,
18119 JSJitInfo_AliasSet::AliasEverything as u8,
18120 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18121 false,
18122 false,
18123 false,
18124 false,
18125 false,
18126 false,
18127 0,
18128 ).to_ne_bytes()
18129 ),
18130});
18131}
18132unsafe extern "C" fn stencilOpSeparate<D: DomTypes>
18133(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18134 let mut result = false;
18135 wrap_panic(&mut || result = (|| {
18136 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18137 let this = &*(this as *const D::WebGL2RenderingContext);
18138 let args = &*args;
18139 let argc = args.argc_;
18140
18141 if argc < 4 {
18142 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.stencilOpSeparate\".");
18143 return false;
18144 }
18145 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
18146 Ok(ConversionResult::Success(value)) => value,
18147 Ok(ConversionResult::Failure(error)) => {
18148 throw_type_error(cx.raw_cx(), &error);
18149 return false;
18150
18151 }
18152 _ => {
18153 return false;
18154
18155 },
18156 }
18157 ;
18158 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
18159 Ok(ConversionResult::Success(value)) => value,
18160 Ok(ConversionResult::Failure(error)) => {
18161 throw_type_error(cx.raw_cx(), &error);
18162 return false;
18163
18164 }
18165 _ => {
18166 return false;
18167
18168 },
18169 }
18170 ;
18171 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
18172 Ok(ConversionResult::Success(value)) => value,
18173 Ok(ConversionResult::Failure(error)) => {
18174 throw_type_error(cx.raw_cx(), &error);
18175 return false;
18176
18177 }
18178 _ => {
18179 return false;
18180
18181 },
18182 }
18183 ;
18184 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
18185 Ok(ConversionResult::Success(value)) => value,
18186 Ok(ConversionResult::Failure(error)) => {
18187 throw_type_error(cx.raw_cx(), &error);
18188 return false;
18189
18190 }
18191 _ => {
18192 return false;
18193
18194 },
18195 }
18196 ;
18197 let result: () = this.StencilOpSeparate(arg0, arg1, arg2, arg3);
18198
18199 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18200 return true;
18201 })());
18202 result
18203}
18204
18205
18206static stencilOpSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18207
18208pub(crate) fn init_stencilOpSeparate_methodinfo<D: DomTypes>() {
18209 stencilOpSeparate_methodinfo.set(JSJitInfo {
18210 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18211 method: Some(stencilOpSeparate::<D>)
18212 },
18213 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18214 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18215 },
18216 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18217 _bitfield_align_1: [],
18218 _bitfield_1: __BindgenBitfieldUnit::new(
18219 new_jsjitinfo_bitfield_1!(
18220 JSJitInfo_OpType::Method as u8,
18221 JSJitInfo_AliasSet::AliasEverything as u8,
18222 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18223 false,
18224 false,
18225 false,
18226 false,
18227 false,
18228 false,
18229 0,
18230 ).to_ne_bytes()
18231 ),
18232});
18233}
18234unsafe extern "C" fn texParameterf<D: DomTypes>
18235(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18236 let mut result = false;
18237 wrap_panic(&mut || result = (|| {
18238 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18239 let this = &*(this as *const D::WebGL2RenderingContext);
18240 let args = &*args;
18241 let argc = args.argc_;
18242
18243 if argc < 3 {
18244 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.texParameterf\".");
18245 return false;
18246 }
18247 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
18248 Ok(ConversionResult::Success(value)) => value,
18249 Ok(ConversionResult::Failure(error)) => {
18250 throw_type_error(cx.raw_cx(), &error);
18251 return false;
18252
18253 }
18254 _ => {
18255 return false;
18256
18257 },
18258 }
18259 ;
18260 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
18261 Ok(ConversionResult::Success(value)) => value,
18262 Ok(ConversionResult::Failure(error)) => {
18263 throw_type_error(cx.raw_cx(), &error);
18264 return false;
18265
18266 }
18267 _ => {
18268 return false;
18269
18270 },
18271 }
18272 ;
18273 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
18274 Ok(ConversionResult::Success(value)) => value,
18275 Ok(ConversionResult::Failure(error)) => {
18276 throw_type_error(cx.raw_cx(), &error);
18277 return false;
18278
18279 }
18280 _ => {
18281 return false;
18282
18283 },
18284 }
18285 ;
18286 let result: () = this.TexParameterf(arg0, arg1, arg2);
18287
18288 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18289 return true;
18290 })());
18291 result
18292}
18293
18294
18295static texParameterf_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18296
18297pub(crate) fn init_texParameterf_methodinfo<D: DomTypes>() {
18298 texParameterf_methodinfo.set(JSJitInfo {
18299 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18300 method: Some(texParameterf::<D>)
18301 },
18302 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18303 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18304 },
18305 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18306 _bitfield_align_1: [],
18307 _bitfield_1: __BindgenBitfieldUnit::new(
18308 new_jsjitinfo_bitfield_1!(
18309 JSJitInfo_OpType::Method as u8,
18310 JSJitInfo_AliasSet::AliasEverything as u8,
18311 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18312 false,
18313 false,
18314 false,
18315 false,
18316 false,
18317 false,
18318 0,
18319 ).to_ne_bytes()
18320 ),
18321});
18322}
18323unsafe extern "C" fn texParameteri<D: DomTypes>
18324(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18325 let mut result = false;
18326 wrap_panic(&mut || result = (|| {
18327 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18328 let this = &*(this as *const D::WebGL2RenderingContext);
18329 let args = &*args;
18330 let argc = args.argc_;
18331
18332 if argc < 3 {
18333 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.texParameteri\".");
18334 return false;
18335 }
18336 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
18337 Ok(ConversionResult::Success(value)) => value,
18338 Ok(ConversionResult::Failure(error)) => {
18339 throw_type_error(cx.raw_cx(), &error);
18340 return false;
18341
18342 }
18343 _ => {
18344 return false;
18345
18346 },
18347 }
18348 ;
18349 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
18350 Ok(ConversionResult::Success(value)) => value,
18351 Ok(ConversionResult::Failure(error)) => {
18352 throw_type_error(cx.raw_cx(), &error);
18353 return false;
18354
18355 }
18356 _ => {
18357 return false;
18358
18359 },
18360 }
18361 ;
18362 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
18363 Ok(ConversionResult::Success(value)) => value,
18364 Ok(ConversionResult::Failure(error)) => {
18365 throw_type_error(cx.raw_cx(), &error);
18366 return false;
18367
18368 }
18369 _ => {
18370 return false;
18371
18372 },
18373 }
18374 ;
18375 let result: () = this.TexParameteri(arg0, arg1, arg2);
18376
18377 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18378 return true;
18379 })());
18380 result
18381}
18382
18383
18384static texParameteri_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18385
18386pub(crate) fn init_texParameteri_methodinfo<D: DomTypes>() {
18387 texParameteri_methodinfo.set(JSJitInfo {
18388 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18389 method: Some(texParameteri::<D>)
18390 },
18391 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18392 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18393 },
18394 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18395 _bitfield_align_1: [],
18396 _bitfield_1: __BindgenBitfieldUnit::new(
18397 new_jsjitinfo_bitfield_1!(
18398 JSJitInfo_OpType::Method as u8,
18399 JSJitInfo_AliasSet::AliasEverything as u8,
18400 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18401 false,
18402 false,
18403 false,
18404 false,
18405 false,
18406 false,
18407 0,
18408 ).to_ne_bytes()
18409 ),
18410});
18411}
18412unsafe extern "C" fn uniform1f<D: DomTypes>
18413(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18414 let mut result = false;
18415 wrap_panic(&mut || result = (|| {
18416 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18417 let this = &*(this as *const D::WebGL2RenderingContext);
18418 let args = &*args;
18419 let argc = args.argc_;
18420
18421 if argc < 2 {
18422 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform1f\".");
18423 return false;
18424 }
18425 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
18426 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
18427 Ok(val) => val,
18428 Err(()) => {
18429 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
18430 return false;
18431
18432 }
18433 }
18434 )
18435 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
18436 None
18437 } else {
18438 throw_type_error(cx.raw_cx(), "Value is not an object.");
18439 return false;
18440
18441 };
18442 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
18443 Ok(ConversionResult::Success(value)) => value,
18444 Ok(ConversionResult::Failure(error)) => {
18445 throw_type_error(cx.raw_cx(), &error);
18446 return false;
18447
18448 }
18449 _ => {
18450 return false;
18451
18452 },
18453 }
18454 ;
18455 let result: () = this.Uniform1f(arg0.as_deref(), arg1);
18456
18457 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18458 return true;
18459 })());
18460 result
18461}
18462
18463
18464static uniform1f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18465
18466pub(crate) fn init_uniform1f_methodinfo<D: DomTypes>() {
18467 uniform1f_methodinfo.set(JSJitInfo {
18468 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18469 method: Some(uniform1f::<D>)
18470 },
18471 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18472 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18473 },
18474 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18475 _bitfield_align_1: [],
18476 _bitfield_1: __BindgenBitfieldUnit::new(
18477 new_jsjitinfo_bitfield_1!(
18478 JSJitInfo_OpType::Method as u8,
18479 JSJitInfo_AliasSet::AliasEverything as u8,
18480 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18481 false,
18482 false,
18483 false,
18484 false,
18485 false,
18486 false,
18487 0,
18488 ).to_ne_bytes()
18489 ),
18490});
18491}
18492unsafe extern "C" fn uniform2f<D: DomTypes>
18493(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18494 let mut result = false;
18495 wrap_panic(&mut || result = (|| {
18496 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18497 let this = &*(this as *const D::WebGL2RenderingContext);
18498 let args = &*args;
18499 let argc = args.argc_;
18500
18501 if argc < 3 {
18502 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform2f\".");
18503 return false;
18504 }
18505 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
18506 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
18507 Ok(val) => val,
18508 Err(()) => {
18509 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
18510 return false;
18511
18512 }
18513 }
18514 )
18515 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
18516 None
18517 } else {
18518 throw_type_error(cx.raw_cx(), "Value is not an object.");
18519 return false;
18520
18521 };
18522 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
18523 Ok(ConversionResult::Success(value)) => value,
18524 Ok(ConversionResult::Failure(error)) => {
18525 throw_type_error(cx.raw_cx(), &error);
18526 return false;
18527
18528 }
18529 _ => {
18530 return false;
18531
18532 },
18533 }
18534 ;
18535 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
18536 Ok(ConversionResult::Success(value)) => value,
18537 Ok(ConversionResult::Failure(error)) => {
18538 throw_type_error(cx.raw_cx(), &error);
18539 return false;
18540
18541 }
18542 _ => {
18543 return false;
18544
18545 },
18546 }
18547 ;
18548 let result: () = this.Uniform2f(arg0.as_deref(), arg1, arg2);
18549
18550 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18551 return true;
18552 })());
18553 result
18554}
18555
18556
18557static uniform2f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18558
18559pub(crate) fn init_uniform2f_methodinfo<D: DomTypes>() {
18560 uniform2f_methodinfo.set(JSJitInfo {
18561 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18562 method: Some(uniform2f::<D>)
18563 },
18564 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18565 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18566 },
18567 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18568 _bitfield_align_1: [],
18569 _bitfield_1: __BindgenBitfieldUnit::new(
18570 new_jsjitinfo_bitfield_1!(
18571 JSJitInfo_OpType::Method as u8,
18572 JSJitInfo_AliasSet::AliasEverything as u8,
18573 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18574 false,
18575 false,
18576 false,
18577 false,
18578 false,
18579 false,
18580 0,
18581 ).to_ne_bytes()
18582 ),
18583});
18584}
18585unsafe extern "C" fn uniform3f<D: DomTypes>
18586(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18587 let mut result = false;
18588 wrap_panic(&mut || result = (|| {
18589 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18590 let this = &*(this as *const D::WebGL2RenderingContext);
18591 let args = &*args;
18592 let argc = args.argc_;
18593
18594 if argc < 4 {
18595 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform3f\".");
18596 return false;
18597 }
18598 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
18599 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
18600 Ok(val) => val,
18601 Err(()) => {
18602 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
18603 return false;
18604
18605 }
18606 }
18607 )
18608 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
18609 None
18610 } else {
18611 throw_type_error(cx.raw_cx(), "Value is not an object.");
18612 return false;
18613
18614 };
18615 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
18616 Ok(ConversionResult::Success(value)) => value,
18617 Ok(ConversionResult::Failure(error)) => {
18618 throw_type_error(cx.raw_cx(), &error);
18619 return false;
18620
18621 }
18622 _ => {
18623 return false;
18624
18625 },
18626 }
18627 ;
18628 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
18629 Ok(ConversionResult::Success(value)) => value,
18630 Ok(ConversionResult::Failure(error)) => {
18631 throw_type_error(cx.raw_cx(), &error);
18632 return false;
18633
18634 }
18635 _ => {
18636 return false;
18637
18638 },
18639 }
18640 ;
18641 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
18642 Ok(ConversionResult::Success(value)) => value,
18643 Ok(ConversionResult::Failure(error)) => {
18644 throw_type_error(cx.raw_cx(), &error);
18645 return false;
18646
18647 }
18648 _ => {
18649 return false;
18650
18651 },
18652 }
18653 ;
18654 let result: () = this.Uniform3f(arg0.as_deref(), arg1, arg2, arg3);
18655
18656 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18657 return true;
18658 })());
18659 result
18660}
18661
18662
18663static uniform3f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18664
18665pub(crate) fn init_uniform3f_methodinfo<D: DomTypes>() {
18666 uniform3f_methodinfo.set(JSJitInfo {
18667 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18668 method: Some(uniform3f::<D>)
18669 },
18670 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18671 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18672 },
18673 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18674 _bitfield_align_1: [],
18675 _bitfield_1: __BindgenBitfieldUnit::new(
18676 new_jsjitinfo_bitfield_1!(
18677 JSJitInfo_OpType::Method as u8,
18678 JSJitInfo_AliasSet::AliasEverything as u8,
18679 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18680 false,
18681 false,
18682 false,
18683 false,
18684 false,
18685 false,
18686 0,
18687 ).to_ne_bytes()
18688 ),
18689});
18690}
18691unsafe extern "C" fn uniform4f<D: DomTypes>
18692(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18693 let mut result = false;
18694 wrap_panic(&mut || result = (|| {
18695 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18696 let this = &*(this as *const D::WebGL2RenderingContext);
18697 let args = &*args;
18698 let argc = args.argc_;
18699
18700 if argc < 5 {
18701 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform4f\".");
18702 return false;
18703 }
18704 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
18705 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
18706 Ok(val) => val,
18707 Err(()) => {
18708 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
18709 return false;
18710
18711 }
18712 }
18713 )
18714 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
18715 None
18716 } else {
18717 throw_type_error(cx.raw_cx(), "Value is not an object.");
18718 return false;
18719
18720 };
18721 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
18722 Ok(ConversionResult::Success(value)) => value,
18723 Ok(ConversionResult::Failure(error)) => {
18724 throw_type_error(cx.raw_cx(), &error);
18725 return false;
18726
18727 }
18728 _ => {
18729 return false;
18730
18731 },
18732 }
18733 ;
18734 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
18735 Ok(ConversionResult::Success(value)) => value,
18736 Ok(ConversionResult::Failure(error)) => {
18737 throw_type_error(cx.raw_cx(), &error);
18738 return false;
18739
18740 }
18741 _ => {
18742 return false;
18743
18744 },
18745 }
18746 ;
18747 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
18748 Ok(ConversionResult::Success(value)) => value,
18749 Ok(ConversionResult::Failure(error)) => {
18750 throw_type_error(cx.raw_cx(), &error);
18751 return false;
18752
18753 }
18754 _ => {
18755 return false;
18756
18757 },
18758 }
18759 ;
18760 let arg4: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ()) {
18761 Ok(ConversionResult::Success(value)) => value,
18762 Ok(ConversionResult::Failure(error)) => {
18763 throw_type_error(cx.raw_cx(), &error);
18764 return false;
18765
18766 }
18767 _ => {
18768 return false;
18769
18770 },
18771 }
18772 ;
18773 let result: () = this.Uniform4f(arg0.as_deref(), arg1, arg2, arg3, arg4);
18774
18775 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18776 return true;
18777 })());
18778 result
18779}
18780
18781
18782static uniform4f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18783
18784pub(crate) fn init_uniform4f_methodinfo<D: DomTypes>() {
18785 uniform4f_methodinfo.set(JSJitInfo {
18786 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18787 method: Some(uniform4f::<D>)
18788 },
18789 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18790 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18791 },
18792 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18793 _bitfield_align_1: [],
18794 _bitfield_1: __BindgenBitfieldUnit::new(
18795 new_jsjitinfo_bitfield_1!(
18796 JSJitInfo_OpType::Method as u8,
18797 JSJitInfo_AliasSet::AliasEverything as u8,
18798 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18799 false,
18800 false,
18801 false,
18802 false,
18803 false,
18804 false,
18805 0,
18806 ).to_ne_bytes()
18807 ),
18808});
18809}
18810unsafe extern "C" fn uniform1i<D: DomTypes>
18811(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18812 let mut result = false;
18813 wrap_panic(&mut || result = (|| {
18814 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18815 let this = &*(this as *const D::WebGL2RenderingContext);
18816 let args = &*args;
18817 let argc = args.argc_;
18818
18819 if argc < 2 {
18820 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform1i\".");
18821 return false;
18822 }
18823 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
18824 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
18825 Ok(val) => val,
18826 Err(()) => {
18827 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
18828 return false;
18829
18830 }
18831 }
18832 )
18833 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
18834 None
18835 } else {
18836 throw_type_error(cx.raw_cx(), "Value is not an object.");
18837 return false;
18838
18839 };
18840 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
18841 Ok(ConversionResult::Success(value)) => value,
18842 Ok(ConversionResult::Failure(error)) => {
18843 throw_type_error(cx.raw_cx(), &error);
18844 return false;
18845
18846 }
18847 _ => {
18848 return false;
18849
18850 },
18851 }
18852 ;
18853 let result: () = this.Uniform1i(arg0.as_deref(), arg1);
18854
18855 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18856 return true;
18857 })());
18858 result
18859}
18860
18861
18862static uniform1i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18863
18864pub(crate) fn init_uniform1i_methodinfo<D: DomTypes>() {
18865 uniform1i_methodinfo.set(JSJitInfo {
18866 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18867 method: Some(uniform1i::<D>)
18868 },
18869 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18870 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18871 },
18872 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18873 _bitfield_align_1: [],
18874 _bitfield_1: __BindgenBitfieldUnit::new(
18875 new_jsjitinfo_bitfield_1!(
18876 JSJitInfo_OpType::Method as u8,
18877 JSJitInfo_AliasSet::AliasEverything as u8,
18878 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18879 false,
18880 false,
18881 false,
18882 false,
18883 false,
18884 false,
18885 0,
18886 ).to_ne_bytes()
18887 ),
18888});
18889}
18890unsafe extern "C" fn uniform2i<D: DomTypes>
18891(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18892 let mut result = false;
18893 wrap_panic(&mut || result = (|| {
18894 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18895 let this = &*(this as *const D::WebGL2RenderingContext);
18896 let args = &*args;
18897 let argc = args.argc_;
18898
18899 if argc < 3 {
18900 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform2i\".");
18901 return false;
18902 }
18903 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
18904 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
18905 Ok(val) => val,
18906 Err(()) => {
18907 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
18908 return false;
18909
18910 }
18911 }
18912 )
18913 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
18914 None
18915 } else {
18916 throw_type_error(cx.raw_cx(), "Value is not an object.");
18917 return false;
18918
18919 };
18920 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
18921 Ok(ConversionResult::Success(value)) => value,
18922 Ok(ConversionResult::Failure(error)) => {
18923 throw_type_error(cx.raw_cx(), &error);
18924 return false;
18925
18926 }
18927 _ => {
18928 return false;
18929
18930 },
18931 }
18932 ;
18933 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
18934 Ok(ConversionResult::Success(value)) => value,
18935 Ok(ConversionResult::Failure(error)) => {
18936 throw_type_error(cx.raw_cx(), &error);
18937 return false;
18938
18939 }
18940 _ => {
18941 return false;
18942
18943 },
18944 }
18945 ;
18946 let result: () = this.Uniform2i(arg0.as_deref(), arg1, arg2);
18947
18948 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18949 return true;
18950 })());
18951 result
18952}
18953
18954
18955static uniform2i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18956
18957pub(crate) fn init_uniform2i_methodinfo<D: DomTypes>() {
18958 uniform2i_methodinfo.set(JSJitInfo {
18959 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18960 method: Some(uniform2i::<D>)
18961 },
18962 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18963 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
18964 },
18965 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18966 _bitfield_align_1: [],
18967 _bitfield_1: __BindgenBitfieldUnit::new(
18968 new_jsjitinfo_bitfield_1!(
18969 JSJitInfo_OpType::Method as u8,
18970 JSJitInfo_AliasSet::AliasEverything as u8,
18971 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18972 false,
18973 false,
18974 false,
18975 false,
18976 false,
18977 false,
18978 0,
18979 ).to_ne_bytes()
18980 ),
18981});
18982}
18983unsafe extern "C" fn uniform3i<D: DomTypes>
18984(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18985 let mut result = false;
18986 wrap_panic(&mut || result = (|| {
18987 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18988 let this = &*(this as *const D::WebGL2RenderingContext);
18989 let args = &*args;
18990 let argc = args.argc_;
18991
18992 if argc < 4 {
18993 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform3i\".");
18994 return false;
18995 }
18996 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
18997 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
18998 Ok(val) => val,
18999 Err(()) => {
19000 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
19001 return false;
19002
19003 }
19004 }
19005 )
19006 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
19007 None
19008 } else {
19009 throw_type_error(cx.raw_cx(), "Value is not an object.");
19010 return false;
19011
19012 };
19013 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
19014 Ok(ConversionResult::Success(value)) => value,
19015 Ok(ConversionResult::Failure(error)) => {
19016 throw_type_error(cx.raw_cx(), &error);
19017 return false;
19018
19019 }
19020 _ => {
19021 return false;
19022
19023 },
19024 }
19025 ;
19026 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
19027 Ok(ConversionResult::Success(value)) => value,
19028 Ok(ConversionResult::Failure(error)) => {
19029 throw_type_error(cx.raw_cx(), &error);
19030 return false;
19031
19032 }
19033 _ => {
19034 return false;
19035
19036 },
19037 }
19038 ;
19039 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
19040 Ok(ConversionResult::Success(value)) => value,
19041 Ok(ConversionResult::Failure(error)) => {
19042 throw_type_error(cx.raw_cx(), &error);
19043 return false;
19044
19045 }
19046 _ => {
19047 return false;
19048
19049 },
19050 }
19051 ;
19052 let result: () = this.Uniform3i(arg0.as_deref(), arg1, arg2, arg3);
19053
19054 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19055 return true;
19056 })());
19057 result
19058}
19059
19060
19061static uniform3i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19062
19063pub(crate) fn init_uniform3i_methodinfo<D: DomTypes>() {
19064 uniform3i_methodinfo.set(JSJitInfo {
19065 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19066 method: Some(uniform3i::<D>)
19067 },
19068 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19069 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19070 },
19071 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19072 _bitfield_align_1: [],
19073 _bitfield_1: __BindgenBitfieldUnit::new(
19074 new_jsjitinfo_bitfield_1!(
19075 JSJitInfo_OpType::Method as u8,
19076 JSJitInfo_AliasSet::AliasEverything as u8,
19077 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19078 false,
19079 false,
19080 false,
19081 false,
19082 false,
19083 false,
19084 0,
19085 ).to_ne_bytes()
19086 ),
19087});
19088}
19089unsafe extern "C" fn uniform4i<D: DomTypes>
19090(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19091 let mut result = false;
19092 wrap_panic(&mut || result = (|| {
19093 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19094 let this = &*(this as *const D::WebGL2RenderingContext);
19095 let args = &*args;
19096 let argc = args.argc_;
19097
19098 if argc < 5 {
19099 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.uniform4i\".");
19100 return false;
19101 }
19102 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
19103 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
19104 Ok(val) => val,
19105 Err(()) => {
19106 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
19107 return false;
19108
19109 }
19110 }
19111 )
19112 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
19113 None
19114 } else {
19115 throw_type_error(cx.raw_cx(), "Value is not an object.");
19116 return false;
19117
19118 };
19119 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
19120 Ok(ConversionResult::Success(value)) => value,
19121 Ok(ConversionResult::Failure(error)) => {
19122 throw_type_error(cx.raw_cx(), &error);
19123 return false;
19124
19125 }
19126 _ => {
19127 return false;
19128
19129 },
19130 }
19131 ;
19132 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
19133 Ok(ConversionResult::Success(value)) => value,
19134 Ok(ConversionResult::Failure(error)) => {
19135 throw_type_error(cx.raw_cx(), &error);
19136 return false;
19137
19138 }
19139 _ => {
19140 return false;
19141
19142 },
19143 }
19144 ;
19145 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
19146 Ok(ConversionResult::Success(value)) => value,
19147 Ok(ConversionResult::Failure(error)) => {
19148 throw_type_error(cx.raw_cx(), &error);
19149 return false;
19150
19151 }
19152 _ => {
19153 return false;
19154
19155 },
19156 }
19157 ;
19158 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
19159 Ok(ConversionResult::Success(value)) => value,
19160 Ok(ConversionResult::Failure(error)) => {
19161 throw_type_error(cx.raw_cx(), &error);
19162 return false;
19163
19164 }
19165 _ => {
19166 return false;
19167
19168 },
19169 }
19170 ;
19171 let result: () = this.Uniform4i(arg0.as_deref(), arg1, arg2, arg3, arg4);
19172
19173 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19174 return true;
19175 })());
19176 result
19177}
19178
19179
19180static uniform4i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19181
19182pub(crate) fn init_uniform4i_methodinfo<D: DomTypes>() {
19183 uniform4i_methodinfo.set(JSJitInfo {
19184 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19185 method: Some(uniform4i::<D>)
19186 },
19187 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19188 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19189 },
19190 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19191 _bitfield_align_1: [],
19192 _bitfield_1: __BindgenBitfieldUnit::new(
19193 new_jsjitinfo_bitfield_1!(
19194 JSJitInfo_OpType::Method as u8,
19195 JSJitInfo_AliasSet::AliasEverything as u8,
19196 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19197 false,
19198 false,
19199 false,
19200 false,
19201 false,
19202 false,
19203 0,
19204 ).to_ne_bytes()
19205 ),
19206});
19207}
19208unsafe extern "C" fn useProgram<D: DomTypes>
19209(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19210 let mut result = false;
19211 wrap_panic(&mut || result = (|| {
19212 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19213 let this = &*(this as *const D::WebGL2RenderingContext);
19214 let args = &*args;
19215 let argc = args.argc_;
19216
19217 if argc < 1 {
19218 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.useProgram\".");
19219 return false;
19220 }
19221 let arg0: Option<DomRoot<D::WebGLProgram>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
19222 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
19223 Ok(val) => val,
19224 Err(()) => {
19225 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
19226 return false;
19227
19228 }
19229 }
19230 )
19231 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
19232 None
19233 } else {
19234 throw_type_error(cx.raw_cx(), "Value is not an object.");
19235 return false;
19236
19237 };
19238 let result: () = this.UseProgram(arg0.as_deref());
19239
19240 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19241 return true;
19242 })());
19243 result
19244}
19245
19246
19247static useProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19248
19249pub(crate) fn init_useProgram_methodinfo<D: DomTypes>() {
19250 useProgram_methodinfo.set(JSJitInfo {
19251 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19252 method: Some(useProgram::<D>)
19253 },
19254 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19255 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19256 },
19257 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19258 _bitfield_align_1: [],
19259 _bitfield_1: __BindgenBitfieldUnit::new(
19260 new_jsjitinfo_bitfield_1!(
19261 JSJitInfo_OpType::Method as u8,
19262 JSJitInfo_AliasSet::AliasEverything as u8,
19263 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19264 false,
19265 false,
19266 false,
19267 false,
19268 false,
19269 false,
19270 0,
19271 ).to_ne_bytes()
19272 ),
19273});
19274}
19275unsafe extern "C" fn validateProgram<D: DomTypes>
19276(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19277 let mut result = false;
19278 wrap_panic(&mut || result = (|| {
19279 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19280 let this = &*(this as *const D::WebGL2RenderingContext);
19281 let args = &*args;
19282 let argc = args.argc_;
19283
19284 if argc < 1 {
19285 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.validateProgram\".");
19286 return false;
19287 }
19288 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
19289 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
19290 Ok(val) => val,
19291 Err(()) => {
19292 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
19293 return false;
19294
19295 }
19296 }
19297
19298 } else {
19299 throw_type_error(cx.raw_cx(), "Value is not an object.");
19300 return false;
19301
19302 };
19303 let result: () = this.ValidateProgram(&arg0);
19304
19305 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19306 return true;
19307 })());
19308 result
19309}
19310
19311
19312static validateProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19313
19314pub(crate) fn init_validateProgram_methodinfo<D: DomTypes>() {
19315 validateProgram_methodinfo.set(JSJitInfo {
19316 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19317 method: Some(validateProgram::<D>)
19318 },
19319 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19320 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19321 },
19322 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19323 _bitfield_align_1: [],
19324 _bitfield_1: __BindgenBitfieldUnit::new(
19325 new_jsjitinfo_bitfield_1!(
19326 JSJitInfo_OpType::Method as u8,
19327 JSJitInfo_AliasSet::AliasEverything as u8,
19328 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19329 false,
19330 false,
19331 false,
19332 false,
19333 false,
19334 false,
19335 0,
19336 ).to_ne_bytes()
19337 ),
19338});
19339}
19340unsafe extern "C" fn vertexAttrib1f<D: DomTypes>
19341(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19342 let mut result = false;
19343 wrap_panic(&mut || result = (|| {
19344 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19345 let this = &*(this as *const D::WebGL2RenderingContext);
19346 let args = &*args;
19347 let argc = args.argc_;
19348
19349 if argc < 2 {
19350 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttrib1f\".");
19351 return false;
19352 }
19353 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19354 Ok(ConversionResult::Success(value)) => value,
19355 Ok(ConversionResult::Failure(error)) => {
19356 throw_type_error(cx.raw_cx(), &error);
19357 return false;
19358
19359 }
19360 _ => {
19361 return false;
19362
19363 },
19364 }
19365 ;
19366 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
19367 Ok(ConversionResult::Success(value)) => value,
19368 Ok(ConversionResult::Failure(error)) => {
19369 throw_type_error(cx.raw_cx(), &error);
19370 return false;
19371
19372 }
19373 _ => {
19374 return false;
19375
19376 },
19377 }
19378 ;
19379 let result: () = this.VertexAttrib1f(arg0, arg1);
19380
19381 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19382 return true;
19383 })());
19384 result
19385}
19386
19387
19388static vertexAttrib1f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19389
19390pub(crate) fn init_vertexAttrib1f_methodinfo<D: DomTypes>() {
19391 vertexAttrib1f_methodinfo.set(JSJitInfo {
19392 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19393 method: Some(vertexAttrib1f::<D>)
19394 },
19395 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19396 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19397 },
19398 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19399 _bitfield_align_1: [],
19400 _bitfield_1: __BindgenBitfieldUnit::new(
19401 new_jsjitinfo_bitfield_1!(
19402 JSJitInfo_OpType::Method as u8,
19403 JSJitInfo_AliasSet::AliasEverything as u8,
19404 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19405 false,
19406 false,
19407 false,
19408 false,
19409 false,
19410 false,
19411 0,
19412 ).to_ne_bytes()
19413 ),
19414});
19415}
19416unsafe extern "C" fn vertexAttrib2f<D: DomTypes>
19417(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19418 let mut result = false;
19419 wrap_panic(&mut || result = (|| {
19420 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19421 let this = &*(this as *const D::WebGL2RenderingContext);
19422 let args = &*args;
19423 let argc = args.argc_;
19424
19425 if argc < 3 {
19426 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttrib2f\".");
19427 return false;
19428 }
19429 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19430 Ok(ConversionResult::Success(value)) => value,
19431 Ok(ConversionResult::Failure(error)) => {
19432 throw_type_error(cx.raw_cx(), &error);
19433 return false;
19434
19435 }
19436 _ => {
19437 return false;
19438
19439 },
19440 }
19441 ;
19442 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
19443 Ok(ConversionResult::Success(value)) => value,
19444 Ok(ConversionResult::Failure(error)) => {
19445 throw_type_error(cx.raw_cx(), &error);
19446 return false;
19447
19448 }
19449 _ => {
19450 return false;
19451
19452 },
19453 }
19454 ;
19455 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
19456 Ok(ConversionResult::Success(value)) => value,
19457 Ok(ConversionResult::Failure(error)) => {
19458 throw_type_error(cx.raw_cx(), &error);
19459 return false;
19460
19461 }
19462 _ => {
19463 return false;
19464
19465 },
19466 }
19467 ;
19468 let result: () = this.VertexAttrib2f(arg0, arg1, arg2);
19469
19470 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19471 return true;
19472 })());
19473 result
19474}
19475
19476
19477static vertexAttrib2f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19478
19479pub(crate) fn init_vertexAttrib2f_methodinfo<D: DomTypes>() {
19480 vertexAttrib2f_methodinfo.set(JSJitInfo {
19481 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19482 method: Some(vertexAttrib2f::<D>)
19483 },
19484 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19485 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19486 },
19487 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19488 _bitfield_align_1: [],
19489 _bitfield_1: __BindgenBitfieldUnit::new(
19490 new_jsjitinfo_bitfield_1!(
19491 JSJitInfo_OpType::Method as u8,
19492 JSJitInfo_AliasSet::AliasEverything as u8,
19493 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19494 false,
19495 false,
19496 false,
19497 false,
19498 false,
19499 false,
19500 0,
19501 ).to_ne_bytes()
19502 ),
19503});
19504}
19505unsafe extern "C" fn vertexAttrib3f<D: DomTypes>
19506(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19507 let mut result = false;
19508 wrap_panic(&mut || result = (|| {
19509 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19510 let this = &*(this as *const D::WebGL2RenderingContext);
19511 let args = &*args;
19512 let argc = args.argc_;
19513
19514 if argc < 4 {
19515 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttrib3f\".");
19516 return false;
19517 }
19518 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19519 Ok(ConversionResult::Success(value)) => value,
19520 Ok(ConversionResult::Failure(error)) => {
19521 throw_type_error(cx.raw_cx(), &error);
19522 return false;
19523
19524 }
19525 _ => {
19526 return false;
19527
19528 },
19529 }
19530 ;
19531 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
19532 Ok(ConversionResult::Success(value)) => value,
19533 Ok(ConversionResult::Failure(error)) => {
19534 throw_type_error(cx.raw_cx(), &error);
19535 return false;
19536
19537 }
19538 _ => {
19539 return false;
19540
19541 },
19542 }
19543 ;
19544 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
19545 Ok(ConversionResult::Success(value)) => value,
19546 Ok(ConversionResult::Failure(error)) => {
19547 throw_type_error(cx.raw_cx(), &error);
19548 return false;
19549
19550 }
19551 _ => {
19552 return false;
19553
19554 },
19555 }
19556 ;
19557 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
19558 Ok(ConversionResult::Success(value)) => value,
19559 Ok(ConversionResult::Failure(error)) => {
19560 throw_type_error(cx.raw_cx(), &error);
19561 return false;
19562
19563 }
19564 _ => {
19565 return false;
19566
19567 },
19568 }
19569 ;
19570 let result: () = this.VertexAttrib3f(arg0, arg1, arg2, arg3);
19571
19572 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19573 return true;
19574 })());
19575 result
19576}
19577
19578
19579static vertexAttrib3f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19580
19581pub(crate) fn init_vertexAttrib3f_methodinfo<D: DomTypes>() {
19582 vertexAttrib3f_methodinfo.set(JSJitInfo {
19583 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19584 method: Some(vertexAttrib3f::<D>)
19585 },
19586 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19587 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19588 },
19589 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19590 _bitfield_align_1: [],
19591 _bitfield_1: __BindgenBitfieldUnit::new(
19592 new_jsjitinfo_bitfield_1!(
19593 JSJitInfo_OpType::Method as u8,
19594 JSJitInfo_AliasSet::AliasEverything as u8,
19595 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19596 false,
19597 false,
19598 false,
19599 false,
19600 false,
19601 false,
19602 0,
19603 ).to_ne_bytes()
19604 ),
19605});
19606}
19607unsafe extern "C" fn vertexAttrib4f<D: DomTypes>
19608(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19609 let mut result = false;
19610 wrap_panic(&mut || result = (|| {
19611 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19612 let this = &*(this as *const D::WebGL2RenderingContext);
19613 let args = &*args;
19614 let argc = args.argc_;
19615
19616 if argc < 5 {
19617 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttrib4f\".");
19618 return false;
19619 }
19620 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19621 Ok(ConversionResult::Success(value)) => value,
19622 Ok(ConversionResult::Failure(error)) => {
19623 throw_type_error(cx.raw_cx(), &error);
19624 return false;
19625
19626 }
19627 _ => {
19628 return false;
19629
19630 },
19631 }
19632 ;
19633 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
19634 Ok(ConversionResult::Success(value)) => value,
19635 Ok(ConversionResult::Failure(error)) => {
19636 throw_type_error(cx.raw_cx(), &error);
19637 return false;
19638
19639 }
19640 _ => {
19641 return false;
19642
19643 },
19644 }
19645 ;
19646 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
19647 Ok(ConversionResult::Success(value)) => value,
19648 Ok(ConversionResult::Failure(error)) => {
19649 throw_type_error(cx.raw_cx(), &error);
19650 return false;
19651
19652 }
19653 _ => {
19654 return false;
19655
19656 },
19657 }
19658 ;
19659 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
19660 Ok(ConversionResult::Success(value)) => value,
19661 Ok(ConversionResult::Failure(error)) => {
19662 throw_type_error(cx.raw_cx(), &error);
19663 return false;
19664
19665 }
19666 _ => {
19667 return false;
19668
19669 },
19670 }
19671 ;
19672 let arg4: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ()) {
19673 Ok(ConversionResult::Success(value)) => value,
19674 Ok(ConversionResult::Failure(error)) => {
19675 throw_type_error(cx.raw_cx(), &error);
19676 return false;
19677
19678 }
19679 _ => {
19680 return false;
19681
19682 },
19683 }
19684 ;
19685 let result: () = this.VertexAttrib4f(arg0, arg1, arg2, arg3, arg4);
19686
19687 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19688 return true;
19689 })());
19690 result
19691}
19692
19693
19694static vertexAttrib4f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19695
19696pub(crate) fn init_vertexAttrib4f_methodinfo<D: DomTypes>() {
19697 vertexAttrib4f_methodinfo.set(JSJitInfo {
19698 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19699 method: Some(vertexAttrib4f::<D>)
19700 },
19701 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19702 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19703 },
19704 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19705 _bitfield_align_1: [],
19706 _bitfield_1: __BindgenBitfieldUnit::new(
19707 new_jsjitinfo_bitfield_1!(
19708 JSJitInfo_OpType::Method as u8,
19709 JSJitInfo_AliasSet::AliasEverything as u8,
19710 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19711 false,
19712 false,
19713 false,
19714 false,
19715 false,
19716 false,
19717 0,
19718 ).to_ne_bytes()
19719 ),
19720});
19721}
19722unsafe extern "C" fn vertexAttrib1fv<D: DomTypes>
19723(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19724 let mut result = false;
19725 wrap_panic(&mut || result = (|| {
19726 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19727 let this = &*(this as *const D::WebGL2RenderingContext);
19728 let args = &*args;
19729 let argc = args.argc_;
19730
19731 if argc < 2 {
19732 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttrib1fv\".");
19733 return false;
19734 }
19735 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19736 Ok(ConversionResult::Success(value)) => value,
19737 Ok(ConversionResult::Failure(error)) => {
19738 throw_type_error(cx.raw_cx(), &error);
19739 return false;
19740
19741 }
19742 _ => {
19743 return false;
19744
19745 },
19746 }
19747 ;
19748 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
19749 Ok(ConversionResult::Success(value)) => value,
19750 Ok(ConversionResult::Failure(error)) => {
19751 throw_type_error(cx.raw_cx(), &error);
19752 return false;
19753
19754 }
19755 _ => {
19756 return false;
19757
19758 },
19759 }
19760 ;
19761 let result: () = this.VertexAttrib1fv(arg0, arg1);
19762
19763 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19764 return true;
19765 })());
19766 result
19767}
19768
19769
19770static vertexAttrib1fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19771
19772pub(crate) fn init_vertexAttrib1fv_methodinfo<D: DomTypes>() {
19773 vertexAttrib1fv_methodinfo.set(JSJitInfo {
19774 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19775 method: Some(vertexAttrib1fv::<D>)
19776 },
19777 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19778 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19779 },
19780 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19781 _bitfield_align_1: [],
19782 _bitfield_1: __BindgenBitfieldUnit::new(
19783 new_jsjitinfo_bitfield_1!(
19784 JSJitInfo_OpType::Method as u8,
19785 JSJitInfo_AliasSet::AliasEverything as u8,
19786 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19787 false,
19788 false,
19789 false,
19790 false,
19791 false,
19792 false,
19793 0,
19794 ).to_ne_bytes()
19795 ),
19796});
19797}
19798unsafe extern "C" fn vertexAttrib2fv<D: DomTypes>
19799(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19800 let mut result = false;
19801 wrap_panic(&mut || result = (|| {
19802 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19803 let this = &*(this as *const D::WebGL2RenderingContext);
19804 let args = &*args;
19805 let argc = args.argc_;
19806
19807 if argc < 2 {
19808 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttrib2fv\".");
19809 return false;
19810 }
19811 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19812 Ok(ConversionResult::Success(value)) => value,
19813 Ok(ConversionResult::Failure(error)) => {
19814 throw_type_error(cx.raw_cx(), &error);
19815 return false;
19816
19817 }
19818 _ => {
19819 return false;
19820
19821 },
19822 }
19823 ;
19824 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
19825 Ok(ConversionResult::Success(value)) => value,
19826 Ok(ConversionResult::Failure(error)) => {
19827 throw_type_error(cx.raw_cx(), &error);
19828 return false;
19829
19830 }
19831 _ => {
19832 return false;
19833
19834 },
19835 }
19836 ;
19837 let result: () = this.VertexAttrib2fv(arg0, arg1);
19838
19839 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19840 return true;
19841 })());
19842 result
19843}
19844
19845
19846static vertexAttrib2fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19847
19848pub(crate) fn init_vertexAttrib2fv_methodinfo<D: DomTypes>() {
19849 vertexAttrib2fv_methodinfo.set(JSJitInfo {
19850 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19851 method: Some(vertexAttrib2fv::<D>)
19852 },
19853 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19854 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19855 },
19856 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19857 _bitfield_align_1: [],
19858 _bitfield_1: __BindgenBitfieldUnit::new(
19859 new_jsjitinfo_bitfield_1!(
19860 JSJitInfo_OpType::Method as u8,
19861 JSJitInfo_AliasSet::AliasEverything as u8,
19862 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19863 false,
19864 false,
19865 false,
19866 false,
19867 false,
19868 false,
19869 0,
19870 ).to_ne_bytes()
19871 ),
19872});
19873}
19874unsafe extern "C" fn vertexAttrib3fv<D: DomTypes>
19875(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19876 let mut result = false;
19877 wrap_panic(&mut || result = (|| {
19878 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19879 let this = &*(this as *const D::WebGL2RenderingContext);
19880 let args = &*args;
19881 let argc = args.argc_;
19882
19883 if argc < 2 {
19884 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttrib3fv\".");
19885 return false;
19886 }
19887 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19888 Ok(ConversionResult::Success(value)) => value,
19889 Ok(ConversionResult::Failure(error)) => {
19890 throw_type_error(cx.raw_cx(), &error);
19891 return false;
19892
19893 }
19894 _ => {
19895 return false;
19896
19897 },
19898 }
19899 ;
19900 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
19901 Ok(ConversionResult::Success(value)) => value,
19902 Ok(ConversionResult::Failure(error)) => {
19903 throw_type_error(cx.raw_cx(), &error);
19904 return false;
19905
19906 }
19907 _ => {
19908 return false;
19909
19910 },
19911 }
19912 ;
19913 let result: () = this.VertexAttrib3fv(arg0, arg1);
19914
19915 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19916 return true;
19917 })());
19918 result
19919}
19920
19921
19922static vertexAttrib3fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19923
19924pub(crate) fn init_vertexAttrib3fv_methodinfo<D: DomTypes>() {
19925 vertexAttrib3fv_methodinfo.set(JSJitInfo {
19926 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19927 method: Some(vertexAttrib3fv::<D>)
19928 },
19929 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19930 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
19931 },
19932 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19933 _bitfield_align_1: [],
19934 _bitfield_1: __BindgenBitfieldUnit::new(
19935 new_jsjitinfo_bitfield_1!(
19936 JSJitInfo_OpType::Method as u8,
19937 JSJitInfo_AliasSet::AliasEverything as u8,
19938 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19939 false,
19940 false,
19941 false,
19942 false,
19943 false,
19944 false,
19945 0,
19946 ).to_ne_bytes()
19947 ),
19948});
19949}
19950unsafe extern "C" fn vertexAttrib4fv<D: DomTypes>
19951(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19952 let mut result = false;
19953 wrap_panic(&mut || result = (|| {
19954 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19955 let this = &*(this as *const D::WebGL2RenderingContext);
19956 let args = &*args;
19957 let argc = args.argc_;
19958
19959 if argc < 2 {
19960 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttrib4fv\".");
19961 return false;
19962 }
19963 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19964 Ok(ConversionResult::Success(value)) => value,
19965 Ok(ConversionResult::Failure(error)) => {
19966 throw_type_error(cx.raw_cx(), &error);
19967 return false;
19968
19969 }
19970 _ => {
19971 return false;
19972
19973 },
19974 }
19975 ;
19976 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
19977 Ok(ConversionResult::Success(value)) => value,
19978 Ok(ConversionResult::Failure(error)) => {
19979 throw_type_error(cx.raw_cx(), &error);
19980 return false;
19981
19982 }
19983 _ => {
19984 return false;
19985
19986 },
19987 }
19988 ;
19989 let result: () = this.VertexAttrib4fv(arg0, arg1);
19990
19991 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19992 return true;
19993 })());
19994 result
19995}
19996
19997
19998static vertexAttrib4fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19999
20000pub(crate) fn init_vertexAttrib4fv_methodinfo<D: DomTypes>() {
20001 vertexAttrib4fv_methodinfo.set(JSJitInfo {
20002 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20003 method: Some(vertexAttrib4fv::<D>)
20004 },
20005 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20006 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
20007 },
20008 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20009 _bitfield_align_1: [],
20010 _bitfield_1: __BindgenBitfieldUnit::new(
20011 new_jsjitinfo_bitfield_1!(
20012 JSJitInfo_OpType::Method as u8,
20013 JSJitInfo_AliasSet::AliasEverything as u8,
20014 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20015 false,
20016 false,
20017 false,
20018 false,
20019 false,
20020 false,
20021 0,
20022 ).to_ne_bytes()
20023 ),
20024});
20025}
20026unsafe extern "C" fn vertexAttribPointer<D: DomTypes>
20027(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20028 let mut result = false;
20029 wrap_panic(&mut || result = (|| {
20030 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20031 let this = &*(this as *const D::WebGL2RenderingContext);
20032 let args = &*args;
20033 let argc = args.argc_;
20034
20035 if argc < 6 {
20036 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.vertexAttribPointer\".");
20037 return false;
20038 }
20039 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20040 Ok(ConversionResult::Success(value)) => value,
20041 Ok(ConversionResult::Failure(error)) => {
20042 throw_type_error(cx.raw_cx(), &error);
20043 return false;
20044
20045 }
20046 _ => {
20047 return false;
20048
20049 },
20050 }
20051 ;
20052 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
20053 Ok(ConversionResult::Success(value)) => value,
20054 Ok(ConversionResult::Failure(error)) => {
20055 throw_type_error(cx.raw_cx(), &error);
20056 return false;
20057
20058 }
20059 _ => {
20060 return false;
20061
20062 },
20063 }
20064 ;
20065 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
20066 Ok(ConversionResult::Success(value)) => value,
20067 Ok(ConversionResult::Failure(error)) => {
20068 throw_type_error(cx.raw_cx(), &error);
20069 return false;
20070
20071 }
20072 _ => {
20073 return false;
20074
20075 },
20076 }
20077 ;
20078 let arg3: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
20079 Ok(ConversionResult::Success(value)) => value,
20080 Ok(ConversionResult::Failure(error)) => {
20081 throw_type_error(cx.raw_cx(), &error);
20082 return false;
20083
20084 }
20085 _ => {
20086 return false;
20087
20088 },
20089 }
20090 ;
20091 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
20092 Ok(ConversionResult::Success(value)) => value,
20093 Ok(ConversionResult::Failure(error)) => {
20094 throw_type_error(cx.raw_cx(), &error);
20095 return false;
20096
20097 }
20098 _ => {
20099 return false;
20100
20101 },
20102 }
20103 ;
20104 let arg5: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
20105 Ok(ConversionResult::Success(value)) => value,
20106 Ok(ConversionResult::Failure(error)) => {
20107 throw_type_error(cx.raw_cx(), &error);
20108 return false;
20109
20110 }
20111 _ => {
20112 return false;
20113
20114 },
20115 }
20116 ;
20117 let result: () = this.VertexAttribPointer(arg0, arg1, arg2, arg3, arg4, arg5);
20118
20119 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20120 return true;
20121 })());
20122 result
20123}
20124
20125
20126static vertexAttribPointer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20127
20128pub(crate) fn init_vertexAttribPointer_methodinfo<D: DomTypes>() {
20129 vertexAttribPointer_methodinfo.set(JSJitInfo {
20130 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20131 method: Some(vertexAttribPointer::<D>)
20132 },
20133 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20134 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
20135 },
20136 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20137 _bitfield_align_1: [],
20138 _bitfield_1: __BindgenBitfieldUnit::new(
20139 new_jsjitinfo_bitfield_1!(
20140 JSJitInfo_OpType::Method as u8,
20141 JSJitInfo_AliasSet::AliasEverything as u8,
20142 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20143 false,
20144 false,
20145 false,
20146 false,
20147 false,
20148 false,
20149 0,
20150 ).to_ne_bytes()
20151 ),
20152});
20153}
20154unsafe extern "C" fn viewport<D: DomTypes>
20155(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20156 let mut result = false;
20157 wrap_panic(&mut || result = (|| {
20158 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20159 let this = &*(this as *const D::WebGL2RenderingContext);
20160 let args = &*args;
20161 let argc = args.argc_;
20162
20163 if argc < 4 {
20164 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGL2RenderingContext.viewport\".");
20165 return false;
20166 }
20167 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20168 Ok(ConversionResult::Success(value)) => value,
20169 Ok(ConversionResult::Failure(error)) => {
20170 throw_type_error(cx.raw_cx(), &error);
20171 return false;
20172
20173 }
20174 _ => {
20175 return false;
20176
20177 },
20178 }
20179 ;
20180 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
20181 Ok(ConversionResult::Success(value)) => value,
20182 Ok(ConversionResult::Failure(error)) => {
20183 throw_type_error(cx.raw_cx(), &error);
20184 return false;
20185
20186 }
20187 _ => {
20188 return false;
20189
20190 },
20191 }
20192 ;
20193 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
20194 Ok(ConversionResult::Success(value)) => value,
20195 Ok(ConversionResult::Failure(error)) => {
20196 throw_type_error(cx.raw_cx(), &error);
20197 return false;
20198
20199 }
20200 _ => {
20201 return false;
20202
20203 },
20204 }
20205 ;
20206 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
20207 Ok(ConversionResult::Success(value)) => value,
20208 Ok(ConversionResult::Failure(error)) => {
20209 throw_type_error(cx.raw_cx(), &error);
20210 return false;
20211
20212 }
20213 _ => {
20214 return false;
20215
20216 },
20217 }
20218 ;
20219 let result: () = this.Viewport(arg0, arg1, arg2, arg3);
20220
20221 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20222 return true;
20223 })());
20224 result
20225}
20226
20227
20228static viewport_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20229
20230pub(crate) fn init_viewport_methodinfo<D: DomTypes>() {
20231 viewport_methodinfo.set(JSJitInfo {
20232 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20233 method: Some(viewport::<D>)
20234 },
20235 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20236 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
20237 },
20238 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20239 _bitfield_align_1: [],
20240 _bitfield_1: __BindgenBitfieldUnit::new(
20241 new_jsjitinfo_bitfield_1!(
20242 JSJitInfo_OpType::Method as u8,
20243 JSJitInfo_AliasSet::AliasEverything as u8,
20244 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20245 false,
20246 false,
20247 false,
20248 false,
20249 false,
20250 false,
20251 0,
20252 ).to_ne_bytes()
20253 ),
20254});
20255}
20256unsafe extern "C" fn makeXRCompatible<D: DomTypes>
20257(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20258 let mut result = false;
20259 wrap_panic(&mut || result = (|| {
20260 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20261 let this = &*(this as *const D::WebGL2RenderingContext);
20262 let args = &*args;
20263 let argc = args.argc_;
20264 let result: Rc<D::Promise> = this.MakeXRCompatible(CanGc::note());
20265
20266 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20267 return true;
20268 })());
20269 result
20270}
20271
20272unsafe extern "C" fn makeXRCompatible_promise_wrapper<D: DomTypes>
20273(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20274 let mut result = false;
20275 wrap_panic(&mut || result = (|| {
20276 let ok = makeXRCompatible::<D>(cx, _obj, this, args);
20277 if ok {
20278 return true;
20279 }
20280 return exception_to_promise(cx, (*args).rval(), CanGc::note());
20281
20282 })());
20283 result
20284}
20285
20286
20287static makeXRCompatible_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20288
20289pub(crate) fn init_makeXRCompatible_methodinfo<D: DomTypes>() {
20290 makeXRCompatible_methodinfo.set(JSJitInfo {
20291 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20292 method: Some(makeXRCompatible_promise_wrapper::<D>)
20293 },
20294 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20295 protoID: PrototypeList::ID::WebGL2RenderingContext as u16,
20296 },
20297 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20298 _bitfield_align_1: [],
20299 _bitfield_1: __BindgenBitfieldUnit::new(
20300 new_jsjitinfo_bitfield_1!(
20301 JSJitInfo_OpType::Method as u8,
20302 JSJitInfo_AliasSet::AliasEverything as u8,
20303 JSValueType::JSVAL_TYPE_OBJECT as u8,
20304 true,
20305 false,
20306 false,
20307 false,
20308 false,
20309 false,
20310 0,
20311 ).to_ne_bytes()
20312 ),
20313});
20314}
20315unsafe extern "C" fn _finalize<D: DomTypes>
20316(_cx: *mut GCContext, obj: *mut JSObject){
20317 wrap_panic(&mut || {
20318
20319 let this = native_from_object_static::<D::WebGL2RenderingContext>(obj).unwrap();
20320 finalize_common(this);
20321 })
20322}
20323
20324unsafe extern "C" fn _trace<D: DomTypes>
20325(trc: *mut JSTracer, obj: *mut JSObject){
20326 wrap_panic(&mut || {
20327
20328 let this = native_from_object_static::<D::WebGL2RenderingContext>(obj).unwrap();
20329 if this.is_null() { return; } (*this).trace(trc);
20331 })
20332}
20333
20334pub mod WebGL2RenderingContextConstants {
20335 pub const READ_BUFFER: u32 = 3074;
20336 pub const UNPACK_ROW_LENGTH: u32 = 3314;
20337 pub const UNPACK_SKIP_ROWS: u32 = 3315;
20338 pub const UNPACK_SKIP_PIXELS: u32 = 3316;
20339 pub const PACK_ROW_LENGTH: u32 = 3330;
20340 pub const PACK_SKIP_ROWS: u32 = 3331;
20341 pub const PACK_SKIP_PIXELS: u32 = 3332;
20342 pub const COLOR: u32 = 6144;
20343 pub const DEPTH: u32 = 6145;
20344 pub const STENCIL: u32 = 6146;
20345 pub const RED: u32 = 6403;
20346 pub const RGB8: u32 = 32849;
20347 pub const RGBA8: u32 = 32856;
20348 pub const RGB10_A2: u32 = 32857;
20349 pub const TEXTURE_BINDING_3D: u32 = 32874;
20350 pub const UNPACK_SKIP_IMAGES: u32 = 32877;
20351 pub const UNPACK_IMAGE_HEIGHT: u32 = 32878;
20352 pub const TEXTURE_3D: u32 = 32879;
20353 pub const TEXTURE_WRAP_R: u32 = 32882;
20354 pub const MAX_3D_TEXTURE_SIZE: u32 = 32883;
20355 pub const UNSIGNED_INT_2_10_10_10_REV: u32 = 33640;
20356 pub const MAX_ELEMENTS_VERTICES: u32 = 33000;
20357 pub const MAX_ELEMENTS_INDICES: u32 = 33001;
20358 pub const TEXTURE_MIN_LOD: u32 = 33082;
20359 pub const TEXTURE_MAX_LOD: u32 = 33083;
20360 pub const TEXTURE_BASE_LEVEL: u32 = 33084;
20361 pub const TEXTURE_MAX_LEVEL: u32 = 33085;
20362 pub const MIN: u32 = 32775;
20363 pub const MAX: u32 = 32776;
20364 pub const DEPTH_COMPONENT24: u32 = 33190;
20365 pub const MAX_TEXTURE_LOD_BIAS: u32 = 34045;
20366 pub const TEXTURE_COMPARE_MODE: u32 = 34892;
20367 pub const TEXTURE_COMPARE_FUNC: u32 = 34893;
20368 pub const CURRENT_QUERY: u32 = 34917;
20369 pub const QUERY_RESULT: u32 = 34918;
20370 pub const QUERY_RESULT_AVAILABLE: u32 = 34919;
20371 pub const STREAM_READ: u32 = 35041;
20372 pub const STREAM_COPY: u32 = 35042;
20373 pub const STATIC_READ: u32 = 35045;
20374 pub const STATIC_COPY: u32 = 35046;
20375 pub const DYNAMIC_READ: u32 = 35049;
20376 pub const DYNAMIC_COPY: u32 = 35050;
20377 pub const MAX_DRAW_BUFFERS: u32 = 34852;
20378 pub const DRAW_BUFFER0: u32 = 34853;
20379 pub const DRAW_BUFFER1: u32 = 34854;
20380 pub const DRAW_BUFFER2: u32 = 34855;
20381 pub const DRAW_BUFFER3: u32 = 34856;
20382 pub const DRAW_BUFFER4: u32 = 34857;
20383 pub const DRAW_BUFFER5: u32 = 34858;
20384 pub const DRAW_BUFFER6: u32 = 34859;
20385 pub const DRAW_BUFFER7: u32 = 34860;
20386 pub const DRAW_BUFFER8: u32 = 34861;
20387 pub const DRAW_BUFFER9: u32 = 34862;
20388 pub const DRAW_BUFFER10: u32 = 34863;
20389 pub const DRAW_BUFFER11: u32 = 34864;
20390 pub const DRAW_BUFFER12: u32 = 34865;
20391 pub const DRAW_BUFFER13: u32 = 34866;
20392 pub const DRAW_BUFFER14: u32 = 34867;
20393 pub const DRAW_BUFFER15: u32 = 34868;
20394 pub const MAX_FRAGMENT_UNIFORM_COMPONENTS: u32 = 35657;
20395 pub const MAX_VERTEX_UNIFORM_COMPONENTS: u32 = 35658;
20396 pub const SAMPLER_3D: u32 = 35679;
20397 pub const SAMPLER_2D_SHADOW: u32 = 35682;
20398 pub const FRAGMENT_SHADER_DERIVATIVE_HINT: u32 = 35723;
20399 pub const PIXEL_PACK_BUFFER: u32 = 35051;
20400 pub const PIXEL_UNPACK_BUFFER: u32 = 35052;
20401 pub const PIXEL_PACK_BUFFER_BINDING: u32 = 35053;
20402 pub const PIXEL_UNPACK_BUFFER_BINDING: u32 = 35055;
20403 pub const FLOAT_MAT2x3: u32 = 35685;
20404 pub const FLOAT_MAT2x4: u32 = 35686;
20405 pub const FLOAT_MAT3x2: u32 = 35687;
20406 pub const FLOAT_MAT3x4: u32 = 35688;
20407 pub const FLOAT_MAT4x2: u32 = 35689;
20408 pub const FLOAT_MAT4x3: u32 = 35690;
20409 pub const SRGB: u32 = 35904;
20410 pub const SRGB8: u32 = 35905;
20411 pub const SRGB8_ALPHA8: u32 = 35907;
20412 pub const COMPARE_REF_TO_TEXTURE: u32 = 34894;
20413 pub const RGBA32F: u32 = 34836;
20414 pub const RGB32F: u32 = 34837;
20415 pub const RGBA16F: u32 = 34842;
20416 pub const RGB16F: u32 = 34843;
20417 pub const VERTEX_ATTRIB_ARRAY_INTEGER: u32 = 35069;
20418 pub const MAX_ARRAY_TEXTURE_LAYERS: u32 = 35071;
20419 pub const MIN_PROGRAM_TEXEL_OFFSET: u32 = 35076;
20420 pub const MAX_PROGRAM_TEXEL_OFFSET: u32 = 35077;
20421 pub const MAX_VARYING_COMPONENTS: u32 = 35659;
20422 pub const TEXTURE_2D_ARRAY: u32 = 35866;
20423 pub const TEXTURE_BINDING_2D_ARRAY: u32 = 35869;
20424 pub const R11F_G11F_B10F: u32 = 35898;
20425 pub const UNSIGNED_INT_10F_11F_11F_REV: u32 = 35899;
20426 pub const RGB9_E5: u32 = 35901;
20427 pub const UNSIGNED_INT_5_9_9_9_REV: u32 = 35902;
20428 pub const TRANSFORM_FEEDBACK_BUFFER_MODE: u32 = 35967;
20429 pub const MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: u32 = 35968;
20430 pub const TRANSFORM_FEEDBACK_VARYINGS: u32 = 35971;
20431 pub const TRANSFORM_FEEDBACK_BUFFER_START: u32 = 35972;
20432 pub const TRANSFORM_FEEDBACK_BUFFER_SIZE: u32 = 35973;
20433 pub const TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: u32 = 35976;
20434 pub const RASTERIZER_DISCARD: u32 = 35977;
20435 pub const MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: u32 = 35978;
20436 pub const MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: u32 = 35979;
20437 pub const INTERLEAVED_ATTRIBS: u32 = 35980;
20438 pub const SEPARATE_ATTRIBS: u32 = 35981;
20439 pub const TRANSFORM_FEEDBACK_BUFFER: u32 = 35982;
20440 pub const TRANSFORM_FEEDBACK_BUFFER_BINDING: u32 = 35983;
20441 pub const RGBA32UI: u32 = 36208;
20442 pub const RGB32UI: u32 = 36209;
20443 pub const RGBA16UI: u32 = 36214;
20444 pub const RGB16UI: u32 = 36215;
20445 pub const RGBA8UI: u32 = 36220;
20446 pub const RGB8UI: u32 = 36221;
20447 pub const RGBA32I: u32 = 36226;
20448 pub const RGB32I: u32 = 36227;
20449 pub const RGBA16I: u32 = 36232;
20450 pub const RGB16I: u32 = 36233;
20451 pub const RGBA8I: u32 = 36238;
20452 pub const RGB8I: u32 = 36239;
20453 pub const RED_INTEGER: u32 = 36244;
20454 pub const RGB_INTEGER: u32 = 36248;
20455 pub const RGBA_INTEGER: u32 = 36249;
20456 pub const SAMPLER_2D_ARRAY: u32 = 36289;
20457 pub const SAMPLER_2D_ARRAY_SHADOW: u32 = 36292;
20458 pub const SAMPLER_CUBE_SHADOW: u32 = 36293;
20459 pub const UNSIGNED_INT_VEC2: u32 = 36294;
20460 pub const UNSIGNED_INT_VEC3: u32 = 36295;
20461 pub const UNSIGNED_INT_VEC4: u32 = 36296;
20462 pub const INT_SAMPLER_2D: u32 = 36298;
20463 pub const INT_SAMPLER_3D: u32 = 36299;
20464 pub const INT_SAMPLER_CUBE: u32 = 36300;
20465 pub const INT_SAMPLER_2D_ARRAY: u32 = 36303;
20466 pub const UNSIGNED_INT_SAMPLER_2D: u32 = 36306;
20467 pub const UNSIGNED_INT_SAMPLER_3D: u32 = 36307;
20468 pub const UNSIGNED_INT_SAMPLER_CUBE: u32 = 36308;
20469 pub const UNSIGNED_INT_SAMPLER_2D_ARRAY: u32 = 36311;
20470 pub const DEPTH_COMPONENT32F: u32 = 36012;
20471 pub const DEPTH32F_STENCIL8: u32 = 36013;
20472 pub const FLOAT_32_UNSIGNED_INT_24_8_REV: u32 = 36269;
20473 pub const FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: u32 = 33296;
20474 pub const FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: u32 = 33297;
20475 pub const FRAMEBUFFER_ATTACHMENT_RED_SIZE: u32 = 33298;
20476 pub const FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: u32 = 33299;
20477 pub const FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: u32 = 33300;
20478 pub const FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: u32 = 33301;
20479 pub const FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: u32 = 33302;
20480 pub const FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: u32 = 33303;
20481 pub const FRAMEBUFFER_DEFAULT: u32 = 33304;
20482 pub const UNSIGNED_INT_24_8: u32 = 34042;
20483 pub const DEPTH24_STENCIL8: u32 = 35056;
20484 pub const UNSIGNED_NORMALIZED: u32 = 35863;
20485 pub const DRAW_FRAMEBUFFER_BINDING: u32 = 36006;
20486 pub const READ_FRAMEBUFFER: u32 = 36008;
20487 pub const DRAW_FRAMEBUFFER: u32 = 36009;
20488 pub const READ_FRAMEBUFFER_BINDING: u32 = 36010;
20489 pub const RENDERBUFFER_SAMPLES: u32 = 36011;
20490 pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: u32 = 36052;
20491 pub const MAX_COLOR_ATTACHMENTS: u32 = 36063;
20492 pub const COLOR_ATTACHMENT1: u32 = 36065;
20493 pub const COLOR_ATTACHMENT2: u32 = 36066;
20494 pub const COLOR_ATTACHMENT3: u32 = 36067;
20495 pub const COLOR_ATTACHMENT4: u32 = 36068;
20496 pub const COLOR_ATTACHMENT5: u32 = 36069;
20497 pub const COLOR_ATTACHMENT6: u32 = 36070;
20498 pub const COLOR_ATTACHMENT7: u32 = 36071;
20499 pub const COLOR_ATTACHMENT8: u32 = 36072;
20500 pub const COLOR_ATTACHMENT9: u32 = 36073;
20501 pub const COLOR_ATTACHMENT10: u32 = 36074;
20502 pub const COLOR_ATTACHMENT11: u32 = 36075;
20503 pub const COLOR_ATTACHMENT12: u32 = 36076;
20504 pub const COLOR_ATTACHMENT13: u32 = 36077;
20505 pub const COLOR_ATTACHMENT14: u32 = 36078;
20506 pub const COLOR_ATTACHMENT15: u32 = 36079;
20507 pub const FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: u32 = 36182;
20508 pub const MAX_SAMPLES: u32 = 36183;
20509 pub const HALF_FLOAT: u32 = 5131;
20510 pub const RG: u32 = 33319;
20511 pub const RG_INTEGER: u32 = 33320;
20512 pub const R8: u32 = 33321;
20513 pub const RG8: u32 = 33323;
20514 pub const R16F: u32 = 33325;
20515 pub const R32F: u32 = 33326;
20516 pub const RG16F: u32 = 33327;
20517 pub const RG32F: u32 = 33328;
20518 pub const R8I: u32 = 33329;
20519 pub const R8UI: u32 = 33330;
20520 pub const R16I: u32 = 33331;
20521 pub const R16UI: u32 = 33332;
20522 pub const R32I: u32 = 33333;
20523 pub const R32UI: u32 = 33334;
20524 pub const RG8I: u32 = 33335;
20525 pub const RG8UI: u32 = 33336;
20526 pub const RG16I: u32 = 33337;
20527 pub const RG16UI: u32 = 33338;
20528 pub const RG32I: u32 = 33339;
20529 pub const RG32UI: u32 = 33340;
20530 pub const VERTEX_ARRAY_BINDING: u32 = 34229;
20531 pub const R8_SNORM: u32 = 36756;
20532 pub const RG8_SNORM: u32 = 36757;
20533 pub const RGB8_SNORM: u32 = 36758;
20534 pub const RGBA8_SNORM: u32 = 36759;
20535 pub const SIGNED_NORMALIZED: u32 = 36764;
20536 pub const COPY_READ_BUFFER: u32 = 36662;
20537 pub const COPY_WRITE_BUFFER: u32 = 36663;
20538 pub const COPY_READ_BUFFER_BINDING: u32 = 36662;
20539 pub const COPY_WRITE_BUFFER_BINDING: u32 = 36663;
20540 pub const UNIFORM_BUFFER: u32 = 35345;
20541 pub const UNIFORM_BUFFER_BINDING: u32 = 35368;
20542 pub const UNIFORM_BUFFER_START: u32 = 35369;
20543 pub const UNIFORM_BUFFER_SIZE: u32 = 35370;
20544 pub const MAX_VERTEX_UNIFORM_BLOCKS: u32 = 35371;
20545 pub const MAX_FRAGMENT_UNIFORM_BLOCKS: u32 = 35373;
20546 pub const MAX_COMBINED_UNIFORM_BLOCKS: u32 = 35374;
20547 pub const MAX_UNIFORM_BUFFER_BINDINGS: u32 = 35375;
20548 pub const MAX_UNIFORM_BLOCK_SIZE: u32 = 35376;
20549 pub const MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: u32 = 35377;
20550 pub const MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: u32 = 35379;
20551 pub const UNIFORM_BUFFER_OFFSET_ALIGNMENT: u32 = 35380;
20552 pub const ACTIVE_UNIFORM_BLOCKS: u32 = 35382;
20553 pub const UNIFORM_TYPE: u32 = 35383;
20554 pub const UNIFORM_SIZE: u32 = 35384;
20555 pub const UNIFORM_BLOCK_INDEX: u32 = 35386;
20556 pub const UNIFORM_OFFSET: u32 = 35387;
20557 pub const UNIFORM_ARRAY_STRIDE: u32 = 35388;
20558 pub const UNIFORM_MATRIX_STRIDE: u32 = 35389;
20559 pub const UNIFORM_IS_ROW_MAJOR: u32 = 35390;
20560 pub const UNIFORM_BLOCK_BINDING: u32 = 35391;
20561 pub const UNIFORM_BLOCK_DATA_SIZE: u32 = 35392;
20562 pub const UNIFORM_BLOCK_ACTIVE_UNIFORMS: u32 = 35394;
20563 pub const UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: u32 = 35395;
20564 pub const UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: u32 = 35396;
20565 pub const UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: u32 = 35398;
20566 pub const INVALID_INDEX: u32 = 4294967295;
20567 pub const MAX_VERTEX_OUTPUT_COMPONENTS: u32 = 37154;
20568 pub const MAX_FRAGMENT_INPUT_COMPONENTS: u32 = 37157;
20569 pub const MAX_SERVER_WAIT_TIMEOUT: u32 = 37137;
20570 pub const OBJECT_TYPE: u32 = 37138;
20571 pub const SYNC_CONDITION: u32 = 37139;
20572 pub const SYNC_STATUS: u32 = 37140;
20573 pub const SYNC_FLAGS: u32 = 37141;
20574 pub const SYNC_FENCE: u32 = 37142;
20575 pub const SYNC_GPU_COMMANDS_COMPLETE: u32 = 37143;
20576 pub const UNSIGNALED: u32 = 37144;
20577 pub const SIGNALED: u32 = 37145;
20578 pub const ALREADY_SIGNALED: u32 = 37146;
20579 pub const TIMEOUT_EXPIRED: u32 = 37147;
20580 pub const CONDITION_SATISFIED: u32 = 37148;
20581 pub const WAIT_FAILED: u32 = 37149;
20582 pub const SYNC_FLUSH_COMMANDS_BIT: u32 = 1;
20583 pub const VERTEX_ATTRIB_ARRAY_DIVISOR: u32 = 35070;
20584 pub const ANY_SAMPLES_PASSED: u32 = 35887;
20585 pub const ANY_SAMPLES_PASSED_CONSERVATIVE: u32 = 36202;
20586 pub const SAMPLER_BINDING: u32 = 35097;
20587 pub const RGB10_A2UI: u32 = 36975;
20588 pub const INT_2_10_10_10_REV: u32 = 36255;
20589 pub const TRANSFORM_FEEDBACK: u32 = 36386;
20590 pub const TRANSFORM_FEEDBACK_PAUSED: u32 = 36387;
20591 pub const TRANSFORM_FEEDBACK_ACTIVE: u32 = 36388;
20592 pub const TRANSFORM_FEEDBACK_BINDING: u32 = 36389;
20593 pub const TEXTURE_IMMUTABLE_FORMAT: u32 = 37167;
20594 pub const MAX_ELEMENT_INDEX: u32 = 36203;
20595 pub const TEXTURE_IMMUTABLE_LEVELS: u32 = 33503;
20596 pub const TIMEOUT_IGNORED: i64 = -1;
20597 pub const MAX_CLIENT_WAIT_TIMEOUT_WEBGL: u32 = 37447;
20598 pub const DEPTH_BUFFER_BIT: u32 = 256;
20599 pub const STENCIL_BUFFER_BIT: u32 = 1024;
20600 pub const COLOR_BUFFER_BIT: u32 = 16384;
20601 pub const POINTS: u32 = 0;
20602 pub const LINES: u32 = 1;
20603 pub const LINE_LOOP: u32 = 2;
20604 pub const LINE_STRIP: u32 = 3;
20605 pub const TRIANGLES: u32 = 4;
20606 pub const TRIANGLE_STRIP: u32 = 5;
20607 pub const TRIANGLE_FAN: u32 = 6;
20608 pub const ZERO: u32 = 0;
20609 pub const ONE: u32 = 1;
20610 pub const SRC_COLOR: u32 = 768;
20611 pub const ONE_MINUS_SRC_COLOR: u32 = 769;
20612 pub const SRC_ALPHA: u32 = 770;
20613 pub const ONE_MINUS_SRC_ALPHA: u32 = 771;
20614 pub const DST_ALPHA: u32 = 772;
20615 pub const ONE_MINUS_DST_ALPHA: u32 = 773;
20616 pub const DST_COLOR: u32 = 774;
20617 pub const ONE_MINUS_DST_COLOR: u32 = 775;
20618 pub const SRC_ALPHA_SATURATE: u32 = 776;
20619 pub const FUNC_ADD: u32 = 32774;
20620 pub const BLEND_EQUATION: u32 = 32777;
20621 pub const BLEND_EQUATION_RGB: u32 = 32777;
20622 pub const BLEND_EQUATION_ALPHA: u32 = 34877;
20623 pub const FUNC_SUBTRACT: u32 = 32778;
20624 pub const FUNC_REVERSE_SUBTRACT: u32 = 32779;
20625 pub const BLEND_DST_RGB: u32 = 32968;
20626 pub const BLEND_SRC_RGB: u32 = 32969;
20627 pub const BLEND_DST_ALPHA: u32 = 32970;
20628 pub const BLEND_SRC_ALPHA: u32 = 32971;
20629 pub const CONSTANT_COLOR: u32 = 32769;
20630 pub const ONE_MINUS_CONSTANT_COLOR: u32 = 32770;
20631 pub const CONSTANT_ALPHA: u32 = 32771;
20632 pub const ONE_MINUS_CONSTANT_ALPHA: u32 = 32772;
20633 pub const BLEND_COLOR: u32 = 32773;
20634 pub const ARRAY_BUFFER: u32 = 34962;
20635 pub const ELEMENT_ARRAY_BUFFER: u32 = 34963;
20636 pub const ARRAY_BUFFER_BINDING: u32 = 34964;
20637 pub const ELEMENT_ARRAY_BUFFER_BINDING: u32 = 34965;
20638 pub const STREAM_DRAW: u32 = 35040;
20639 pub const STATIC_DRAW: u32 = 35044;
20640 pub const DYNAMIC_DRAW: u32 = 35048;
20641 pub const BUFFER_SIZE: u32 = 34660;
20642 pub const BUFFER_USAGE: u32 = 34661;
20643 pub const CURRENT_VERTEX_ATTRIB: u32 = 34342;
20644 pub const FRONT: u32 = 1028;
20645 pub const BACK: u32 = 1029;
20646 pub const FRONT_AND_BACK: u32 = 1032;
20647 pub const CULL_FACE: u32 = 2884;
20648 pub const BLEND: u32 = 3042;
20649 pub const DITHER: u32 = 3024;
20650 pub const STENCIL_TEST: u32 = 2960;
20651 pub const DEPTH_TEST: u32 = 2929;
20652 pub const SCISSOR_TEST: u32 = 3089;
20653 pub const POLYGON_OFFSET_FILL: u32 = 32823;
20654 pub const SAMPLE_ALPHA_TO_COVERAGE: u32 = 32926;
20655 pub const SAMPLE_COVERAGE: u32 = 32928;
20656 pub const NO_ERROR: u32 = 0;
20657 pub const INVALID_ENUM: u32 = 1280;
20658 pub const INVALID_VALUE: u32 = 1281;
20659 pub const INVALID_OPERATION: u32 = 1282;
20660 pub const OUT_OF_MEMORY: u32 = 1285;
20661 pub const CW: u32 = 2304;
20662 pub const CCW: u32 = 2305;
20663 pub const LINE_WIDTH: u32 = 2849;
20664 pub const ALIASED_POINT_SIZE_RANGE: u32 = 33901;
20665 pub const ALIASED_LINE_WIDTH_RANGE: u32 = 33902;
20666 pub const CULL_FACE_MODE: u32 = 2885;
20667 pub const FRONT_FACE: u32 = 2886;
20668 pub const DEPTH_RANGE: u32 = 2928;
20669 pub const DEPTH_WRITEMASK: u32 = 2930;
20670 pub const DEPTH_CLEAR_VALUE: u32 = 2931;
20671 pub const DEPTH_FUNC: u32 = 2932;
20672 pub const STENCIL_CLEAR_VALUE: u32 = 2961;
20673 pub const STENCIL_FUNC: u32 = 2962;
20674 pub const STENCIL_FAIL: u32 = 2964;
20675 pub const STENCIL_PASS_DEPTH_FAIL: u32 = 2965;
20676 pub const STENCIL_PASS_DEPTH_PASS: u32 = 2966;
20677 pub const STENCIL_REF: u32 = 2967;
20678 pub const STENCIL_VALUE_MASK: u32 = 2963;
20679 pub const STENCIL_WRITEMASK: u32 = 2968;
20680 pub const STENCIL_BACK_FUNC: u32 = 34816;
20681 pub const STENCIL_BACK_FAIL: u32 = 34817;
20682 pub const STENCIL_BACK_PASS_DEPTH_FAIL: u32 = 34818;
20683 pub const STENCIL_BACK_PASS_DEPTH_PASS: u32 = 34819;
20684 pub const STENCIL_BACK_REF: u32 = 36003;
20685 pub const STENCIL_BACK_VALUE_MASK: u32 = 36004;
20686 pub const STENCIL_BACK_WRITEMASK: u32 = 36005;
20687 pub const VIEWPORT: u32 = 2978;
20688 pub const SCISSOR_BOX: u32 = 3088;
20689 pub const COLOR_CLEAR_VALUE: u32 = 3106;
20690 pub const COLOR_WRITEMASK: u32 = 3107;
20691 pub const UNPACK_ALIGNMENT: u32 = 3317;
20692 pub const PACK_ALIGNMENT: u32 = 3333;
20693 pub const MAX_TEXTURE_SIZE: u32 = 3379;
20694 pub const MAX_VIEWPORT_DIMS: u32 = 3386;
20695 pub const SUBPIXEL_BITS: u32 = 3408;
20696 pub const RED_BITS: u32 = 3410;
20697 pub const GREEN_BITS: u32 = 3411;
20698 pub const BLUE_BITS: u32 = 3412;
20699 pub const ALPHA_BITS: u32 = 3413;
20700 pub const DEPTH_BITS: u32 = 3414;
20701 pub const STENCIL_BITS: u32 = 3415;
20702 pub const POLYGON_OFFSET_UNITS: u32 = 10752;
20703 pub const POLYGON_OFFSET_FACTOR: u32 = 32824;
20704 pub const TEXTURE_BINDING_2D: u32 = 32873;
20705 pub const SAMPLE_BUFFERS: u32 = 32936;
20706 pub const SAMPLES: u32 = 32937;
20707 pub const SAMPLE_COVERAGE_VALUE: u32 = 32938;
20708 pub const SAMPLE_COVERAGE_INVERT: u32 = 32939;
20709 pub const COMPRESSED_TEXTURE_FORMATS: u32 = 34467;
20710 pub const DONT_CARE: u32 = 4352;
20711 pub const FASTEST: u32 = 4353;
20712 pub const NICEST: u32 = 4354;
20713 pub const GENERATE_MIPMAP_HINT: u32 = 33170;
20714 pub const BYTE: u32 = 5120;
20715 pub const UNSIGNED_BYTE: u32 = 5121;
20716 pub const SHORT: u32 = 5122;
20717 pub const UNSIGNED_SHORT: u32 = 5123;
20718 pub const INT: u32 = 5124;
20719 pub const UNSIGNED_INT: u32 = 5125;
20720 pub const FLOAT: u32 = 5126;
20721 pub const DEPTH_COMPONENT: u32 = 6402;
20722 pub const ALPHA: u32 = 6406;
20723 pub const RGB: u32 = 6407;
20724 pub const RGBA: u32 = 6408;
20725 pub const LUMINANCE: u32 = 6409;
20726 pub const LUMINANCE_ALPHA: u32 = 6410;
20727 pub const UNSIGNED_SHORT_4_4_4_4: u32 = 32819;
20728 pub const UNSIGNED_SHORT_5_5_5_1: u32 = 32820;
20729 pub const UNSIGNED_SHORT_5_6_5: u32 = 33635;
20730 pub const FRAGMENT_SHADER: u32 = 35632;
20731 pub const VERTEX_SHADER: u32 = 35633;
20732 pub const MAX_VERTEX_ATTRIBS: u32 = 34921;
20733 pub const MAX_VERTEX_UNIFORM_VECTORS: u32 = 36347;
20734 pub const MAX_VARYING_VECTORS: u32 = 36348;
20735 pub const MAX_COMBINED_TEXTURE_IMAGE_UNITS: u32 = 35661;
20736 pub const MAX_VERTEX_TEXTURE_IMAGE_UNITS: u32 = 35660;
20737 pub const MAX_TEXTURE_IMAGE_UNITS: u32 = 34930;
20738 pub const MAX_FRAGMENT_UNIFORM_VECTORS: u32 = 36349;
20739 pub const SHADER_TYPE: u32 = 35663;
20740 pub const DELETE_STATUS: u32 = 35712;
20741 pub const LINK_STATUS: u32 = 35714;
20742 pub const VALIDATE_STATUS: u32 = 35715;
20743 pub const ATTACHED_SHADERS: u32 = 35717;
20744 pub const ACTIVE_UNIFORMS: u32 = 35718;
20745 pub const ACTIVE_ATTRIBUTES: u32 = 35721;
20746 pub const SHADING_LANGUAGE_VERSION: u32 = 35724;
20747 pub const CURRENT_PROGRAM: u32 = 35725;
20748 pub const NEVER: u32 = 512;
20749 pub const LESS: u32 = 513;
20750 pub const EQUAL: u32 = 514;
20751 pub const LEQUAL: u32 = 515;
20752 pub const GREATER: u32 = 516;
20753 pub const NOTEQUAL: u32 = 517;
20754 pub const GEQUAL: u32 = 518;
20755 pub const ALWAYS: u32 = 519;
20756 pub const KEEP: u32 = 7680;
20757 pub const REPLACE: u32 = 7681;
20758 pub const INCR: u32 = 7682;
20759 pub const DECR: u32 = 7683;
20760 pub const INVERT: u32 = 5386;
20761 pub const INCR_WRAP: u32 = 34055;
20762 pub const DECR_WRAP: u32 = 34056;
20763 pub const VENDOR: u32 = 7936;
20764 pub const RENDERER: u32 = 7937;
20765 pub const VERSION: u32 = 7938;
20766 pub const NEAREST: u32 = 9728;
20767 pub const LINEAR: u32 = 9729;
20768 pub const NEAREST_MIPMAP_NEAREST: u32 = 9984;
20769 pub const LINEAR_MIPMAP_NEAREST: u32 = 9985;
20770 pub const NEAREST_MIPMAP_LINEAR: u32 = 9986;
20771 pub const LINEAR_MIPMAP_LINEAR: u32 = 9987;
20772 pub const TEXTURE_MAG_FILTER: u32 = 10240;
20773 pub const TEXTURE_MIN_FILTER: u32 = 10241;
20774 pub const TEXTURE_WRAP_S: u32 = 10242;
20775 pub const TEXTURE_WRAP_T: u32 = 10243;
20776 pub const TEXTURE_2D: u32 = 3553;
20777 pub const TEXTURE: u32 = 5890;
20778 pub const TEXTURE_CUBE_MAP: u32 = 34067;
20779 pub const TEXTURE_BINDING_CUBE_MAP: u32 = 34068;
20780 pub const TEXTURE_CUBE_MAP_POSITIVE_X: u32 = 34069;
20781 pub const TEXTURE_CUBE_MAP_NEGATIVE_X: u32 = 34070;
20782 pub const TEXTURE_CUBE_MAP_POSITIVE_Y: u32 = 34071;
20783 pub const TEXTURE_CUBE_MAP_NEGATIVE_Y: u32 = 34072;
20784 pub const TEXTURE_CUBE_MAP_POSITIVE_Z: u32 = 34073;
20785 pub const TEXTURE_CUBE_MAP_NEGATIVE_Z: u32 = 34074;
20786 pub const MAX_CUBE_MAP_TEXTURE_SIZE: u32 = 34076;
20787 pub const TEXTURE0: u32 = 33984;
20788 pub const TEXTURE1: u32 = 33985;
20789 pub const TEXTURE2: u32 = 33986;
20790 pub const TEXTURE3: u32 = 33987;
20791 pub const TEXTURE4: u32 = 33988;
20792 pub const TEXTURE5: u32 = 33989;
20793 pub const TEXTURE6: u32 = 33990;
20794 pub const TEXTURE7: u32 = 33991;
20795 pub const TEXTURE8: u32 = 33992;
20796 pub const TEXTURE9: u32 = 33993;
20797 pub const TEXTURE10: u32 = 33994;
20798 pub const TEXTURE11: u32 = 33995;
20799 pub const TEXTURE12: u32 = 33996;
20800 pub const TEXTURE13: u32 = 33997;
20801 pub const TEXTURE14: u32 = 33998;
20802 pub const TEXTURE15: u32 = 33999;
20803 pub const TEXTURE16: u32 = 34000;
20804 pub const TEXTURE17: u32 = 34001;
20805 pub const TEXTURE18: u32 = 34002;
20806 pub const TEXTURE19: u32 = 34003;
20807 pub const TEXTURE20: u32 = 34004;
20808 pub const TEXTURE21: u32 = 34005;
20809 pub const TEXTURE22: u32 = 34006;
20810 pub const TEXTURE23: u32 = 34007;
20811 pub const TEXTURE24: u32 = 34008;
20812 pub const TEXTURE25: u32 = 34009;
20813 pub const TEXTURE26: u32 = 34010;
20814 pub const TEXTURE27: u32 = 34011;
20815 pub const TEXTURE28: u32 = 34012;
20816 pub const TEXTURE29: u32 = 34013;
20817 pub const TEXTURE30: u32 = 34014;
20818 pub const TEXTURE31: u32 = 34015;
20819 pub const ACTIVE_TEXTURE: u32 = 34016;
20820 pub const REPEAT: u32 = 10497;
20821 pub const CLAMP_TO_EDGE: u32 = 33071;
20822 pub const MIRRORED_REPEAT: u32 = 33648;
20823 pub const FLOAT_VEC2: u32 = 35664;
20824 pub const FLOAT_VEC3: u32 = 35665;
20825 pub const FLOAT_VEC4: u32 = 35666;
20826 pub const INT_VEC2: u32 = 35667;
20827 pub const INT_VEC3: u32 = 35668;
20828 pub const INT_VEC4: u32 = 35669;
20829 pub const BOOL: u32 = 35670;
20830 pub const BOOL_VEC2: u32 = 35671;
20831 pub const BOOL_VEC3: u32 = 35672;
20832 pub const BOOL_VEC4: u32 = 35673;
20833 pub const FLOAT_MAT2: u32 = 35674;
20834 pub const FLOAT_MAT3: u32 = 35675;
20835 pub const FLOAT_MAT4: u32 = 35676;
20836 pub const SAMPLER_2D: u32 = 35678;
20837 pub const SAMPLER_CUBE: u32 = 35680;
20838 pub const VERTEX_ATTRIB_ARRAY_ENABLED: u32 = 34338;
20839 pub const VERTEX_ATTRIB_ARRAY_SIZE: u32 = 34339;
20840 pub const VERTEX_ATTRIB_ARRAY_STRIDE: u32 = 34340;
20841 pub const VERTEX_ATTRIB_ARRAY_TYPE: u32 = 34341;
20842 pub const VERTEX_ATTRIB_ARRAY_NORMALIZED: u32 = 34922;
20843 pub const VERTEX_ATTRIB_ARRAY_POINTER: u32 = 34373;
20844 pub const VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: u32 = 34975;
20845 pub const IMPLEMENTATION_COLOR_READ_TYPE: u32 = 35738;
20846 pub const IMPLEMENTATION_COLOR_READ_FORMAT: u32 = 35739;
20847 pub const COMPILE_STATUS: u32 = 35713;
20848 pub const LOW_FLOAT: u32 = 36336;
20849 pub const MEDIUM_FLOAT: u32 = 36337;
20850 pub const HIGH_FLOAT: u32 = 36338;
20851 pub const LOW_INT: u32 = 36339;
20852 pub const MEDIUM_INT: u32 = 36340;
20853 pub const HIGH_INT: u32 = 36341;
20854 pub const FRAMEBUFFER: u32 = 36160;
20855 pub const RENDERBUFFER: u32 = 36161;
20856 pub const RGBA4: u32 = 32854;
20857 pub const RGB5_A1: u32 = 32855;
20858 pub const RGB565: u32 = 36194;
20859 pub const DEPTH_COMPONENT16: u32 = 33189;
20860 pub const STENCIL_INDEX8: u32 = 36168;
20861 pub const DEPTH_STENCIL: u32 = 34041;
20862 pub const RENDERBUFFER_WIDTH: u32 = 36162;
20863 pub const RENDERBUFFER_HEIGHT: u32 = 36163;
20864 pub const RENDERBUFFER_INTERNAL_FORMAT: u32 = 36164;
20865 pub const RENDERBUFFER_RED_SIZE: u32 = 36176;
20866 pub const RENDERBUFFER_GREEN_SIZE: u32 = 36177;
20867 pub const RENDERBUFFER_BLUE_SIZE: u32 = 36178;
20868 pub const RENDERBUFFER_ALPHA_SIZE: u32 = 36179;
20869 pub const RENDERBUFFER_DEPTH_SIZE: u32 = 36180;
20870 pub const RENDERBUFFER_STENCIL_SIZE: u32 = 36181;
20871 pub const FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: u32 = 36048;
20872 pub const FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: u32 = 36049;
20873 pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: u32 = 36050;
20874 pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: u32 = 36051;
20875 pub const COLOR_ATTACHMENT0: u32 = 36064;
20876 pub const DEPTH_ATTACHMENT: u32 = 36096;
20877 pub const STENCIL_ATTACHMENT: u32 = 36128;
20878 pub const DEPTH_STENCIL_ATTACHMENT: u32 = 33306;
20879 pub const NONE: u32 = 0;
20880 pub const FRAMEBUFFER_COMPLETE: u32 = 36053;
20881 pub const FRAMEBUFFER_INCOMPLETE_ATTACHMENT: u32 = 36054;
20882 pub const FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: u32 = 36055;
20883 pub const FRAMEBUFFER_INCOMPLETE_DIMENSIONS: u32 = 36057;
20884 pub const FRAMEBUFFER_UNSUPPORTED: u32 = 36061;
20885 pub const FRAMEBUFFER_BINDING: u32 = 36006;
20886 pub const RENDERBUFFER_BINDING: u32 = 36007;
20887 pub const MAX_RENDERBUFFER_SIZE: u32 = 34024;
20888 pub const INVALID_FRAMEBUFFER_OPERATION: u32 = 1286;
20889 pub const UNPACK_FLIP_Y_WEBGL: u32 = 37440;
20890 pub const UNPACK_PREMULTIPLY_ALPHA_WEBGL: u32 = 37441;
20891 pub const CONTEXT_LOST_WEBGL: u32 = 37442;
20892 pub const UNPACK_COLORSPACE_CONVERSION_WEBGL: u32 = 37443;
20893 pub const BROWSER_DEFAULT_WEBGL: u32 = 37444;
20894} static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();
20897
20898pub(crate) fn init_class_ops<D: DomTypes>() {
20899 CLASS_OPS.set(JSClassOps {
20900 addProperty: None,
20901 delProperty: None,
20902 enumerate: None,
20903 newEnumerate: None,
20904 resolve: None,
20905 mayResolve: None,
20906 finalize: Some(_finalize::<D>),
20907 call: None,
20908 construct: None,
20909 trace: Some(_trace::<D>),
20910 });
20911}
20912
20913pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();
20914
20915pub(crate) fn init_domjs_class<D: DomTypes>() {
20916 init_class_ops::<D>();
20917 Class.set(DOMJSClass {
20918 base: JSClass {
20919 name: c"WebGL2RenderingContext".as_ptr(),
20920 flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
20921 (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
20922 ,
20923 cOps: unsafe { CLASS_OPS.get() },
20924 spec: ptr::null(),
20925 ext: ptr::null(),
20926 oOps: ptr::null(),
20927 },
20928 dom_class:
20929DOMClass {
20930 interface_chain: [ PrototypeList::ID::WebGL2RenderingContext, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
20931 depth: 0,
20932 type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
20933 malloc_size_of: malloc_size_of_including_raw_self::<D::WebGL2RenderingContext> as unsafe fn(&mut _, _) -> _,
20934 global: Globals::EMPTY,
20935},
20936 });
20937}
20938
20939#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
20940(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::WebGL2RenderingContext>, _can_gc: CanGc) -> DomRoot<D::WebGL2RenderingContext>{
20941
20942 let raw = Root::new(MaybeUnreflectedDom::from_box(object));
20943
20944 let scope = scope.reflector().get_jsobject();
20945 assert!(!scope.get().is_null());
20946 assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
20947 let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());
20948
20949 rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
20950 GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
20951 assert!(!canonical_proto.is_null());
20952
20953
20954 rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
20955 if let Some(given) = given_proto {
20956 proto.set(*given);
20957 if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
20958 assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
20959 }
20960 } else {
20961 proto.set(*canonical_proto);
20962 }
20963 rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
20964 cx.raw_cx(),
20965 &Class.get().base,
20966 proto.handle(),
20967 ));
20968 assert!(!obj.is_null());
20969 JS_SetReservedSlot(
20970 obj.get(),
20971 DOM_OBJECT_SLOT,
20972 &PrivateValue(raw.as_ptr() as *const libc::c_void),
20973 );
20974
20975 let root = raw.reflect_with(obj.get());
20976
20977
20978
20979 DomRoot::from_ref(&*root)
20980}
20981
20982pub trait WebGL2RenderingContextMethods<D: DomTypes> {
20983 fn CopyBufferSubData(&self, r#readTarget: u32, r#writeTarget: u32, r#readOffset: i64, r#writeOffset: i64, r#size: i64);
20984 fn GetBufferSubData(&self, r#target: u32, r#srcByteOffset: i64, r#dstBuffer: CustomAutoRooterGuard<typedarray::ArrayBufferView>, r#dstOffset: u32, r#length: u32);
20985 fn BlitFramebuffer(&self, r#srcX0: i32, r#srcY0: i32, r#srcX1: i32, r#srcY1: i32, r#dstX0: i32, r#dstY0: i32, r#dstX1: i32, r#dstY1: i32, r#mask: u32, r#filter: u32);
20986 fn FramebufferTextureLayer(&self, r#target: u32, r#attachment: u32, r#texture: Option<&D::WebGLTexture>, r#level: i32, r#layer: i32);
20987 fn InvalidateFramebuffer(&self, r#target: u32, r#attachments: Vec<u32>);
20988 fn InvalidateSubFramebuffer(&self, r#target: u32, r#attachments: Vec<u32>, r#x: i32, r#y: i32, r#width: i32, r#height: i32);
20989 fn ReadBuffer(&self, r#src: u32);
20990 fn GetInternalformatParameter(&self, r#cx: SafeJSContext, r#target: u32, r#internalformat: u32, r#pname: u32, r#rval: MutableHandleValue);
20991 fn RenderbufferStorageMultisample(&self, r#target: u32, r#samples: i32, r#internalformat: u32, r#width: i32, r#height: i32);
20992 fn TexStorage2D(&self, r#target: u32, r#levels: i32, r#internalformat: u32, r#width: i32, r#height: i32);
20993 fn TexStorage3D(&self, r#target: u32, r#levels: i32, r#internalformat: u32, r#width: i32, r#height: i32, r#depth: i32);
20994 fn TexImage3D(&self, r#target: u32, r#level: i32, r#internalformat: i32, r#width: i32, r#height: i32, r#depth: i32, r#border: i32, r#format: u32, r#type_: u32, r#srcData: CustomAutoRooterGuard<Option<typedarray::ArrayBufferView>>) -> Fallible<()>;
20995 fn GetFragDataLocation(&self, r#program: &D::WebGLProgram, r#name: DOMString) -> i32;
20996 fn Uniform1ui(&self, r#location: Option<&D::WebGLUniformLocation>, r#v0: u32);
20997 fn Uniform2ui(&self, r#location: Option<&D::WebGLUniformLocation>, r#v0: u32, r#v1: u32);
20998 fn Uniform3ui(&self, r#location: Option<&D::WebGLUniformLocation>, r#v0: u32, r#v1: u32, r#v2: u32);
20999 fn Uniform4ui(&self, r#location: Option<&D::WebGLUniformLocation>, r#v0: u32, r#v1: u32, r#v2: u32, r#v3: u32);
21000 fn Uniform1uiv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence, r#srcOffset: u32, r#srcLength: u32);
21001 fn Uniform2uiv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence, r#srcOffset: u32, r#srcLength: u32);
21002 fn Uniform3uiv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence, r#srcOffset: u32, r#srcLength: u32);
21003 fn Uniform4uiv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence, r#srcOffset: u32, r#srcLength: u32);
21004 fn UniformMatrix3x2fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21005 fn UniformMatrix4x2fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21006 fn UniformMatrix2x3fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21007 fn UniformMatrix4x3fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21008 fn UniformMatrix2x4fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21009 fn UniformMatrix3x4fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21010 fn VertexAttribI4i(&self, r#index: u32, r#x: i32, r#y: i32, r#z: i32, r#w: i32);
21011 fn VertexAttribI4iv(&self, r#index: u32, r#values: GenericUnionTypes::Int32ArrayOrLongSequence);
21012 fn VertexAttribI4ui(&self, r#index: u32, r#x: u32, r#y: u32, r#z: u32, r#w: u32);
21013 fn VertexAttribI4uiv(&self, r#index: u32, r#values: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence);
21014 fn VertexAttribIPointer(&self, r#index: u32, r#size: i32, r#type_: u32, r#stride: i32, r#offset: i64);
21015 fn VertexAttribDivisor(&self, r#index: u32, r#divisor: u32);
21016 fn DrawArraysInstanced(&self, r#mode: u32, r#first: i32, r#count: i32, r#instanceCount: i32);
21017 fn DrawElementsInstanced(&self, r#mode: u32, r#count: i32, r#type_: u32, r#offset: i64, r#instanceCount: i32);
21018 fn DrawRangeElements(&self, r#mode: u32, r#start: u32, r#end: u32, r#count: i32, r#type_: u32, r#offset: i64);
21019 fn DrawBuffers(&self, r#buffers: Vec<u32>);
21020 fn ClearBufferfv(&self, r#buffer: u32, r#drawbuffer: i32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32);
21021 fn ClearBufferiv(&self, r#buffer: u32, r#drawbuffer: i32, r#values: GenericUnionTypes::Int32ArrayOrLongSequence, r#srcOffset: u32);
21022 fn ClearBufferuiv(&self, r#buffer: u32, r#drawbuffer: i32, r#values: GenericUnionTypes::Uint32ArrayOrUnsignedLongSequence, r#srcOffset: u32);
21023 fn ClearBufferfi(&self, r#buffer: u32, r#drawbuffer: i32, r#depth: f32, r#stencil: i32);
21024 fn CreateQuery(&self, ) -> Option<DomRoot<D::WebGLQuery>>;
21025 fn DeleteQuery(&self, r#query: Option<&D::WebGLQuery>);
21026 fn IsQuery(&self, r#query: Option<&D::WebGLQuery>) -> bool;
21027 fn BeginQuery(&self, r#target: u32, r#query: &D::WebGLQuery);
21028 fn EndQuery(&self, r#target: u32);
21029 fn GetQuery(&self, r#target: u32, r#pname: u32) -> Option<DomRoot<D::WebGLQuery>>;
21030 fn GetQueryParameter(&self, r#cx: SafeJSContext, r#query: &D::WebGLQuery, r#pname: u32, r#rval: MutableHandleValue);
21031 fn CreateSampler(&self, ) -> Option<DomRoot<D::WebGLSampler>>;
21032 fn DeleteSampler(&self, r#sampler: Option<&D::WebGLSampler>);
21033 fn IsSampler(&self, r#sampler: Option<&D::WebGLSampler>) -> bool;
21034 fn BindSampler(&self, r#unit: u32, r#sampler: Option<&D::WebGLSampler>);
21035 fn SamplerParameteri(&self, r#sampler: &D::WebGLSampler, r#pname: u32, r#param: i32);
21036 fn SamplerParameterf(&self, r#sampler: &D::WebGLSampler, r#pname: u32, r#param: f32);
21037 fn GetSamplerParameter(&self, r#cx: SafeJSContext, r#sampler: &D::WebGLSampler, r#pname: u32, r#rval: MutableHandleValue);
21038 fn FenceSync(&self, r#condition: u32, r#flags: u32) -> Option<DomRoot<D::WebGLSync>>;
21039 fn IsSync(&self, r#sync: Option<&D::WebGLSync>) -> bool;
21040 fn DeleteSync(&self, r#sync: Option<&D::WebGLSync>);
21041 fn ClientWaitSync(&self, r#sync: &D::WebGLSync, r#flags: u32, r#timeout: u64) -> u32;
21042 fn WaitSync(&self, r#sync: &D::WebGLSync, r#flags: u32, r#timeout: i64);
21043 fn GetSyncParameter(&self, r#cx: SafeJSContext, r#sync: &D::WebGLSync, r#pname: u32, r#rval: MutableHandleValue);
21044 fn CreateTransformFeedback(&self, ) -> Option<DomRoot<D::WebGLTransformFeedback>>;
21045 fn DeleteTransformFeedback(&self, r#tf: Option<&D::WebGLTransformFeedback>);
21046 fn IsTransformFeedback(&self, r#tf: Option<&D::WebGLTransformFeedback>) -> bool;
21047 fn BindTransformFeedback(&self, r#target: u32, r#tf: Option<&D::WebGLTransformFeedback>);
21048 fn BeginTransformFeedback(&self, r#primitiveMode: u32);
21049 fn EndTransformFeedback(&self, );
21050 fn TransformFeedbackVaryings(&self, r#program: &D::WebGLProgram, r#varyings: Vec<DOMString>, r#bufferMode: u32);
21051 fn GetTransformFeedbackVarying(&self, r#program: &D::WebGLProgram, r#index: u32) -> Option<DomRoot<D::WebGLActiveInfo>>;
21052 fn PauseTransformFeedback(&self, );
21053 fn ResumeTransformFeedback(&self, );
21054 fn BindBufferBase(&self, r#target: u32, r#index: u32, r#buffer: Option<&D::WebGLBuffer>);
21055 fn BindBufferRange(&self, r#target: u32, r#index: u32, r#buffer: Option<&D::WebGLBuffer>, r#offset: i64, r#size: i64);
21056 fn GetIndexedParameter(&self, r#cx: SafeJSContext, r#target: u32, r#index: u32, r#rval: MutableHandleValue);
21057 fn GetUniformIndices(&self, r#program: &D::WebGLProgram, r#uniformNames: Vec<DOMString>) -> Option<Vec<u32>>;
21058 fn GetActiveUniforms(&self, r#cx: SafeJSContext, r#program: &D::WebGLProgram, r#uniformIndices: Vec<u32>, r#pname: u32, r#rval: MutableHandleValue);
21059 fn GetUniformBlockIndex(&self, r#program: &D::WebGLProgram, r#uniformBlockName: DOMString) -> u32;
21060 fn GetActiveUniformBlockParameter(&self, r#cx: SafeJSContext, r#program: &D::WebGLProgram, r#uniformBlockIndex: u32, r#pname: u32, r#rval: MutableHandleValue);
21061 fn GetActiveUniformBlockName(&self, r#program: &D::WebGLProgram, r#uniformBlockIndex: u32) -> Option<DOMString>;
21062 fn UniformBlockBinding(&self, r#program: &D::WebGLProgram, r#uniformBlockIndex: u32, r#uniformBlockBinding: u32);
21063 fn CreateVertexArray(&self, ) -> Option<DomRoot<D::WebGLVertexArrayObject>>;
21064 fn DeleteVertexArray(&self, r#vertexArray: Option<&D::WebGLVertexArrayObject>);
21065 fn IsVertexArray(&self, r#vertexArray: Option<&D::WebGLVertexArrayObject>) -> bool;
21066 fn BindVertexArray(&self, r#array: Option<&D::WebGLVertexArrayObject>);
21067 fn BufferData(&self, r#target: u32, r#size: i64, r#usage: u32);
21068 fn BufferData_(&self, r#target: u32, r#srcData: Option<GenericUnionTypes::ArrayBufferViewOrArrayBuffer >, r#usage: u32);
21069 fn BufferData__(&self, r#target: u32, r#srcData: CustomAutoRooterGuard<typedarray::ArrayBufferView>, r#usage: u32, r#srcOffset: u32, r#length: u32);
21070 fn BufferSubData(&self, r#target: u32, r#dstByteOffset: i64, r#srcData: GenericUnionTypes::ArrayBufferViewOrArrayBuffer);
21071 fn BufferSubData_(&self, r#target: u32, r#dstByteOffset: i64, r#srcData: CustomAutoRooterGuard<typedarray::ArrayBufferView>, r#srcOffset: u32, r#length: u32);
21072 fn TexImage2D(&self, r#target: u32, r#level: i32, r#internalformat: i32, r#width: i32, r#height: i32, r#border: i32, r#format: u32, r#type_: u32, r#pixels: CustomAutoRooterGuard<Option<typedarray::ArrayBufferView>>) -> Fallible<()>;
21073 fn TexImage2D_(&self, r#target: u32, r#level: i32, r#internalformat: i32, r#format: u32, r#type_: u32, r#source: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>) -> Fallible<()>;
21074 fn TexImage2D__(&self, r#target: u32, r#level: i32, r#internalformat: i32, r#width: i32, r#height: i32, r#border: i32, r#format: u32, r#type_: u32, r#pboOffset: i64) -> Fallible<()>;
21075 fn TexImage2D___(&self, r#target: u32, r#level: i32, r#internalformat: i32, r#width: i32, r#height: i32, r#border: i32, r#format: u32, r#type_: u32, r#source: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>) -> Fallible<()>;
21076 fn TexImage2D____(&self, r#target: u32, r#level: i32, r#internalformat: i32, r#width: i32, r#height: i32, r#border: i32, r#format: u32, r#type_: u32, r#srcData: CustomAutoRooterGuard<typedarray::ArrayBufferView>, r#srcOffset: u32) -> Fallible<()>;
21077 fn TexSubImage2D(&self, r#target: u32, r#level: i32, r#xoffset: i32, r#yoffset: i32, r#width: i32, r#height: i32, r#format: u32, r#type_: u32, r#pixels: CustomAutoRooterGuard<Option<typedarray::ArrayBufferView>>) -> Fallible<()>;
21078 fn TexSubImage2D_(&self, r#target: u32, r#level: i32, r#xoffset: i32, r#yoffset: i32, r#format: u32, r#type_: u32, r#source: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>) -> Fallible<()>;
21079 fn CompressedTexImage2D(&self, r#target: u32, r#level: i32, r#internalformat: u32, r#width: i32, r#height: i32, r#border: i32, r#srcData: CustomAutoRooterGuard<typedarray::ArrayBufferView>, r#srcOffset: u32, r#srcLengthOverride: u32);
21080 fn CompressedTexSubImage2D(&self, r#target: u32, r#level: i32, r#xoffset: i32, r#yoffset: i32, r#width: i32, r#height: i32, r#format: u32, r#srcData: CustomAutoRooterGuard<typedarray::ArrayBufferView>, r#srcOffset: u32, r#srcLengthOverride: u32);
21081 fn Uniform1fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21082 fn Uniform2fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21083 fn Uniform3fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21084 fn Uniform4fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21085 fn Uniform1iv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Int32ArrayOrLongSequence, r#srcOffset: u32, r#srcLength: u32);
21086 fn Uniform2iv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Int32ArrayOrLongSequence, r#srcOffset: u32, r#srcLength: u32);
21087 fn Uniform3iv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Int32ArrayOrLongSequence, r#srcOffset: u32, r#srcLength: u32);
21088 fn Uniform4iv(&self, r#location: Option<&D::WebGLUniformLocation>, r#data: GenericUnionTypes::Int32ArrayOrLongSequence, r#srcOffset: u32, r#srcLength: u32);
21089 fn UniformMatrix2fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21090 fn UniformMatrix3fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21091 fn UniformMatrix4fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#data: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence, r#srcOffset: u32, r#srcLength: u32);
21092 fn ReadPixels(&self, r#x: i32, r#y: i32, r#width: i32, r#height: i32, r#format: u32, r#type_: u32, r#dstData: CustomAutoRooterGuard<Option<typedarray::ArrayBufferView>>);
21093 fn ReadPixels_(&self, r#x: i32, r#y: i32, r#width: i32, r#height: i32, r#format: u32, r#type_: u32, r#offset: i64);
21094 fn ReadPixels__(&self, r#x: i32, r#y: i32, r#width: i32, r#height: i32, r#format: u32, r#type_: u32, r#dstData: CustomAutoRooterGuard<typedarray::ArrayBufferView>, r#dstOffset: u32);
21095 fn Canvas(&self, ) -> GenericUnionTypes::HTMLCanvasElementOrOffscreenCanvas::<D>;
21096 fn DrawingBufferWidth(&self, ) -> i32;
21097 fn DrawingBufferHeight(&self, ) -> i32;
21098 fn GetContextAttributes(&self, ) -> Option<WebGLContextAttributes>;
21099 fn IsContextLost(&self, ) -> bool;
21100 fn GetSupportedExtensions(&self, ) -> Option<Vec<DOMString>>;
21101 fn GetExtension(&self, r#cx: SafeJSContext, r#name: DOMString) -> Option<NonNull<JSObject>>;
21102 fn ActiveTexture(&self, r#texture: u32);
21103 fn AttachShader(&self, r#program: &D::WebGLProgram, r#shader: &D::WebGLShader);
21104 fn BindAttribLocation(&self, r#program: &D::WebGLProgram, r#index: u32, r#name: DOMString);
21105 fn BindBuffer(&self, r#target: u32, r#buffer: Option<&D::WebGLBuffer>);
21106 fn BindFramebuffer(&self, r#target: u32, r#framebuffer: Option<&D::WebGLFramebuffer>);
21107 fn BindRenderbuffer(&self, r#target: u32, r#renderbuffer: Option<&D::WebGLRenderbuffer>);
21108 fn BindTexture(&self, r#target: u32, r#texture: Option<&D::WebGLTexture>);
21109 fn BlendColor(&self, r#red: f32, r#green: f32, r#blue: f32, r#alpha: f32);
21110 fn BlendEquation(&self, r#mode: u32);
21111 fn BlendEquationSeparate(&self, r#modeRGB: u32, r#modeAlpha: u32);
21112 fn BlendFunc(&self, r#sfactor: u32, r#dfactor: u32);
21113 fn BlendFuncSeparate(&self, r#srcRGB: u32, r#dstRGB: u32, r#srcAlpha: u32, r#dstAlpha: u32);
21114 fn CheckFramebufferStatus(&self, r#target: u32) -> u32;
21115 fn Clear(&self, r#mask: u32);
21116 fn ClearColor(&self, r#red: f32, r#green: f32, r#blue: f32, r#alpha: f32);
21117 fn ClearDepth(&self, r#depth: f32);
21118 fn ClearStencil(&self, r#s: i32);
21119 fn ColorMask(&self, r#red: bool, r#green: bool, r#blue: bool, r#alpha: bool);
21120 fn CompileShader(&self, r#shader: &D::WebGLShader);
21121 fn CopyTexImage2D(&self, r#target: u32, r#level: i32, r#internalformat: u32, r#x: i32, r#y: i32, r#width: i32, r#height: i32, r#border: i32);
21122 fn CopyTexSubImage2D(&self, r#target: u32, r#level: i32, r#xoffset: i32, r#yoffset: i32, r#x: i32, r#y: i32, r#width: i32, r#height: i32);
21123 fn CreateBuffer(&self, ) -> Option<DomRoot<D::WebGLBuffer>>;
21124 fn CreateFramebuffer(&self, ) -> Option<DomRoot<D::WebGLFramebuffer>>;
21125 fn CreateProgram(&self, ) -> Option<DomRoot<D::WebGLProgram>>;
21126 fn CreateRenderbuffer(&self, ) -> Option<DomRoot<D::WebGLRenderbuffer>>;
21127 fn CreateShader(&self, r#type_: u32) -> Option<DomRoot<D::WebGLShader>>;
21128 fn CreateTexture(&self, ) -> Option<DomRoot<D::WebGLTexture>>;
21129 fn CullFace(&self, r#mode: u32);
21130 fn DeleteBuffer(&self, r#buffer: Option<&D::WebGLBuffer>);
21131 fn DeleteFramebuffer(&self, r#framebuffer: Option<&D::WebGLFramebuffer>);
21132 fn DeleteProgram(&self, r#program: Option<&D::WebGLProgram>);
21133 fn DeleteRenderbuffer(&self, r#renderbuffer: Option<&D::WebGLRenderbuffer>);
21134 fn DeleteShader(&self, r#shader: Option<&D::WebGLShader>);
21135 fn DeleteTexture(&self, r#texture: Option<&D::WebGLTexture>);
21136 fn DepthFunc(&self, r#func: u32);
21137 fn DepthMask(&self, r#flag: bool);
21138 fn DepthRange(&self, r#zNear: f32, r#zFar: f32);
21139 fn DetachShader(&self, r#program: &D::WebGLProgram, r#shader: &D::WebGLShader);
21140 fn Disable(&self, r#cap: u32);
21141 fn DisableVertexAttribArray(&self, r#index: u32);
21142 fn DrawArrays(&self, r#mode: u32, r#first: i32, r#count: i32);
21143 fn DrawElements(&self, r#mode: u32, r#count: i32, r#type_: u32, r#offset: i64);
21144 fn Enable(&self, r#cap: u32);
21145 fn EnableVertexAttribArray(&self, r#index: u32);
21146 fn Finish(&self, );
21147 fn Flush(&self, );
21148 fn FramebufferRenderbuffer(&self, r#target: u32, r#attachment: u32, r#renderbuffertarget: u32, r#renderbuffer: Option<&D::WebGLRenderbuffer>);
21149 fn FramebufferTexture2D(&self, r#target: u32, r#attachment: u32, r#textarget: u32, r#texture: Option<&D::WebGLTexture>, r#level: i32);
21150 fn FrontFace(&self, r#mode: u32);
21151 fn GenerateMipmap(&self, r#target: u32);
21152 fn GetActiveAttrib(&self, r#program: &D::WebGLProgram, r#index: u32) -> Option<DomRoot<D::WebGLActiveInfo>>;
21153 fn GetActiveUniform(&self, r#program: &D::WebGLProgram, r#index: u32) -> Option<DomRoot<D::WebGLActiveInfo>>;
21154 fn GetAttachedShaders(&self, r#program: &D::WebGLProgram) -> Option<Vec<DomRoot<D::WebGLShader>>>;
21155 fn GetAttribLocation(&self, r#program: &D::WebGLProgram, r#name: DOMString) -> i32;
21156 fn GetBufferParameter(&self, r#cx: SafeJSContext, r#target: u32, r#pname: u32, r#rval: MutableHandleValue);
21157 fn GetParameter(&self, r#cx: SafeJSContext, r#pname: u32, r#rval: MutableHandleValue);
21158 fn GetError(&self, ) -> u32;
21159 fn GetFramebufferAttachmentParameter(&self, r#cx: SafeJSContext, r#target: u32, r#attachment: u32, r#pname: u32, r#rval: MutableHandleValue);
21160 fn GetProgramParameter(&self, r#cx: SafeJSContext, r#program: &D::WebGLProgram, r#pname: u32, r#rval: MutableHandleValue);
21161 fn GetProgramInfoLog(&self, r#program: &D::WebGLProgram) -> Option<DOMString>;
21162 fn GetRenderbufferParameter(&self, r#cx: SafeJSContext, r#target: u32, r#pname: u32, r#rval: MutableHandleValue);
21163 fn GetShaderParameter(&self, r#cx: SafeJSContext, r#shader: &D::WebGLShader, r#pname: u32, r#rval: MutableHandleValue);
21164 fn GetShaderPrecisionFormat(&self, r#shadertype: u32, r#precisiontype: u32) -> Option<DomRoot<D::WebGLShaderPrecisionFormat>>;
21165 fn GetShaderInfoLog(&self, r#shader: &D::WebGLShader) -> Option<DOMString>;
21166 fn GetShaderSource(&self, r#shader: &D::WebGLShader) -> Option<DOMString>;
21167 fn GetTexParameter(&self, r#cx: SafeJSContext, r#target: u32, r#pname: u32, r#rval: MutableHandleValue);
21168 fn GetUniform(&self, r#cx: SafeJSContext, r#program: &D::WebGLProgram, r#location: &D::WebGLUniformLocation, r#rval: MutableHandleValue);
21169 fn GetUniformLocation(&self, r#program: &D::WebGLProgram, r#name: DOMString) -> Option<DomRoot<D::WebGLUniformLocation>>;
21170 fn GetVertexAttrib(&self, r#cx: SafeJSContext, r#index: u32, r#pname: u32, r#rval: MutableHandleValue);
21171 fn GetVertexAttribOffset(&self, r#index: u32, r#pname: u32) -> i64;
21172 fn Hint(&self, r#target: u32, r#mode: u32);
21173 fn IsBuffer(&self, r#buffer: Option<&D::WebGLBuffer>) -> bool;
21174 fn IsEnabled(&self, r#cap: u32) -> bool;
21175 fn IsFramebuffer(&self, r#framebuffer: Option<&D::WebGLFramebuffer>) -> bool;
21176 fn IsProgram(&self, r#program: Option<&D::WebGLProgram>) -> bool;
21177 fn IsRenderbuffer(&self, r#renderbuffer: Option<&D::WebGLRenderbuffer>) -> bool;
21178 fn IsShader(&self, r#shader: Option<&D::WebGLShader>) -> bool;
21179 fn IsTexture(&self, r#texture: Option<&D::WebGLTexture>) -> bool;
21180 fn LineWidth(&self, r#width: f32);
21181 fn LinkProgram(&self, r#program: &D::WebGLProgram);
21182 fn PixelStorei(&self, r#pname: u32, r#param: i32);
21183 fn PolygonOffset(&self, r#factor: f32, r#units: f32);
21184 fn RenderbufferStorage(&self, r#target: u32, r#internalformat: u32, r#width: i32, r#height: i32);
21185 fn SampleCoverage(&self, r#value: f32, r#invert: bool);
21186 fn Scissor(&self, r#x: i32, r#y: i32, r#width: i32, r#height: i32);
21187 fn ShaderSource(&self, r#shader: &D::WebGLShader, r#source: DOMString);
21188 fn StencilFunc(&self, r#func: u32, r#ref_: i32, r#mask: u32);
21189 fn StencilFuncSeparate(&self, r#face: u32, r#func: u32, r#ref_: i32, r#mask: u32);
21190 fn StencilMask(&self, r#mask: u32);
21191 fn StencilMaskSeparate(&self, r#face: u32, r#mask: u32);
21192 fn StencilOp(&self, r#fail: u32, r#zfail: u32, r#zpass: u32);
21193 fn StencilOpSeparate(&self, r#face: u32, r#fail: u32, r#zfail: u32, r#zpass: u32);
21194 fn TexParameterf(&self, r#target: u32, r#pname: u32, r#param: f32);
21195 fn TexParameteri(&self, r#target: u32, r#pname: u32, r#param: i32);
21196 fn Uniform1f(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: f32);
21197 fn Uniform2f(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: f32, r#y: f32);
21198 fn Uniform3f(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: f32, r#y: f32, r#z: f32);
21199 fn Uniform4f(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: f32, r#y: f32, r#z: f32, r#w: f32);
21200 fn Uniform1i(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: i32);
21201 fn Uniform2i(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: i32, r#y: i32);
21202 fn Uniform3i(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: i32, r#y: i32, r#z: i32);
21203 fn Uniform4i(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: i32, r#y: i32, r#z: i32, r#w: i32);
21204 fn UseProgram(&self, r#program: Option<&D::WebGLProgram>);
21205 fn ValidateProgram(&self, r#program: &D::WebGLProgram);
21206 fn VertexAttrib1f(&self, r#indx: u32, r#x: f32);
21207 fn VertexAttrib2f(&self, r#indx: u32, r#x: f32, r#y: f32);
21208 fn VertexAttrib3f(&self, r#indx: u32, r#x: f32, r#y: f32, r#z: f32);
21209 fn VertexAttrib4f(&self, r#indx: u32, r#x: f32, r#y: f32, r#z: f32, r#w: f32);
21210 fn VertexAttrib1fv(&self, r#indx: u32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
21211 fn VertexAttrib2fv(&self, r#indx: u32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
21212 fn VertexAttrib3fv(&self, r#indx: u32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
21213 fn VertexAttrib4fv(&self, r#indx: u32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
21214 fn VertexAttribPointer(&self, r#indx: u32, r#size: i32, r#type_: u32, r#normalized: bool, r#stride: i32, r#offset: i64);
21215 fn Viewport(&self, r#x: i32, r#y: i32, r#width: i32, r#height: i32);
21216 fn MakeXRCompatible(&self, r#_can_gc: CanGc) -> Rc<D::Promise>;
21217}
21218static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
21219
21220pub(crate) fn init_sMethods_specs<D: DomTypes>() {
21221 sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
21222 JSFunctionSpec {
21223 name: JSPropertySpec_Name { string_: c"copyBufferSubData".as_ptr() },
21224 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyBufferSubData_methodinfo.get() } as *const _ as *const JSJitInfo },
21225 nargs: 5,
21226 flags: (JSPROP_ENUMERATE) as u16,
21227 selfHostedName: ptr::null()
21228 },
21229 JSFunctionSpec {
21230 name: JSPropertySpec_Name { string_: c"getBufferSubData".as_ptr() },
21231 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getBufferSubData_methodinfo.get() } as *const _ as *const JSJitInfo },
21232 nargs: 3,
21233 flags: (JSPROP_ENUMERATE) as u16,
21234 selfHostedName: ptr::null()
21235 },
21236 JSFunctionSpec {
21237 name: JSPropertySpec_Name { string_: c"blitFramebuffer".as_ptr() },
21238 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blitFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
21239 nargs: 10,
21240 flags: (JSPROP_ENUMERATE) as u16,
21241 selfHostedName: ptr::null()
21242 },
21243 JSFunctionSpec {
21244 name: JSPropertySpec_Name { string_: c"framebufferTextureLayer".as_ptr() },
21245 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { framebufferTextureLayer_methodinfo.get() } as *const _ as *const JSJitInfo },
21246 nargs: 5,
21247 flags: (JSPROP_ENUMERATE) as u16,
21248 selfHostedName: ptr::null()
21249 },
21250 JSFunctionSpec {
21251 name: JSPropertySpec_Name { string_: c"invalidateFramebuffer".as_ptr() },
21252 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { invalidateFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
21253 nargs: 2,
21254 flags: (JSPROP_ENUMERATE) as u16,
21255 selfHostedName: ptr::null()
21256 },
21257 JSFunctionSpec {
21258 name: JSPropertySpec_Name { string_: c"invalidateSubFramebuffer".as_ptr() },
21259 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { invalidateSubFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
21260 nargs: 6,
21261 flags: (JSPROP_ENUMERATE) as u16,
21262 selfHostedName: ptr::null()
21263 },
21264 JSFunctionSpec {
21265 name: JSPropertySpec_Name { string_: c"readBuffer".as_ptr() },
21266 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { readBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
21267 nargs: 1,
21268 flags: (JSPROP_ENUMERATE) as u16,
21269 selfHostedName: ptr::null()
21270 },
21271 JSFunctionSpec {
21272 name: JSPropertySpec_Name { string_: c"getInternalformatParameter".as_ptr() },
21273 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getInternalformatParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
21274 nargs: 3,
21275 flags: (JSPROP_ENUMERATE) as u16,
21276 selfHostedName: ptr::null()
21277 },
21278 JSFunctionSpec {
21279 name: JSPropertySpec_Name { string_: c"renderbufferStorageMultisample".as_ptr() },
21280 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { renderbufferStorageMultisample_methodinfo.get() } as *const _ as *const JSJitInfo },
21281 nargs: 5,
21282 flags: (JSPROP_ENUMERATE) as u16,
21283 selfHostedName: ptr::null()
21284 },
21285 JSFunctionSpec {
21286 name: JSPropertySpec_Name { string_: c"texStorage2D".as_ptr() },
21287 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texStorage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
21288 nargs: 5,
21289 flags: (JSPROP_ENUMERATE) as u16,
21290 selfHostedName: ptr::null()
21291 },
21292 JSFunctionSpec {
21293 name: JSPropertySpec_Name { string_: c"texStorage3D".as_ptr() },
21294 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texStorage3D_methodinfo.get() } as *const _ as *const JSJitInfo },
21295 nargs: 6,
21296 flags: (JSPROP_ENUMERATE) as u16,
21297 selfHostedName: ptr::null()
21298 },
21299 JSFunctionSpec {
21300 name: JSPropertySpec_Name { string_: c"texImage3D".as_ptr() },
21301 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texImage3D_methodinfo.get() } as *const _ as *const JSJitInfo },
21302 nargs: 10,
21303 flags: (JSPROP_ENUMERATE) as u16,
21304 selfHostedName: ptr::null()
21305 },
21306 JSFunctionSpec {
21307 name: JSPropertySpec_Name { string_: c"getFragDataLocation".as_ptr() },
21308 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getFragDataLocation_methodinfo.get() } as *const _ as *const JSJitInfo },
21309 nargs: 2,
21310 flags: (JSPROP_ENUMERATE) as u16,
21311 selfHostedName: ptr::null()
21312 },
21313 JSFunctionSpec {
21314 name: JSPropertySpec_Name { string_: c"uniform1ui".as_ptr() },
21315 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1ui_methodinfo.get() } as *const _ as *const JSJitInfo },
21316 nargs: 2,
21317 flags: (JSPROP_ENUMERATE) as u16,
21318 selfHostedName: ptr::null()
21319 },
21320 JSFunctionSpec {
21321 name: JSPropertySpec_Name { string_: c"uniform2ui".as_ptr() },
21322 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2ui_methodinfo.get() } as *const _ as *const JSJitInfo },
21323 nargs: 3,
21324 flags: (JSPROP_ENUMERATE) as u16,
21325 selfHostedName: ptr::null()
21326 },
21327 JSFunctionSpec {
21328 name: JSPropertySpec_Name { string_: c"uniform3ui".as_ptr() },
21329 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3ui_methodinfo.get() } as *const _ as *const JSJitInfo },
21330 nargs: 4,
21331 flags: (JSPROP_ENUMERATE) as u16,
21332 selfHostedName: ptr::null()
21333 },
21334 JSFunctionSpec {
21335 name: JSPropertySpec_Name { string_: c"uniform4ui".as_ptr() },
21336 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4ui_methodinfo.get() } as *const _ as *const JSJitInfo },
21337 nargs: 5,
21338 flags: (JSPROP_ENUMERATE) as u16,
21339 selfHostedName: ptr::null()
21340 },
21341 JSFunctionSpec {
21342 name: JSPropertySpec_Name { string_: c"uniform1uiv".as_ptr() },
21343 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1uiv_methodinfo.get() } as *const _ as *const JSJitInfo },
21344 nargs: 2,
21345 flags: (JSPROP_ENUMERATE) as u16,
21346 selfHostedName: ptr::null()
21347 },
21348 JSFunctionSpec {
21349 name: JSPropertySpec_Name { string_: c"uniform2uiv".as_ptr() },
21350 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2uiv_methodinfo.get() } as *const _ as *const JSJitInfo },
21351 nargs: 2,
21352 flags: (JSPROP_ENUMERATE) as u16,
21353 selfHostedName: ptr::null()
21354 },
21355 JSFunctionSpec {
21356 name: JSPropertySpec_Name { string_: c"uniform3uiv".as_ptr() },
21357 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3uiv_methodinfo.get() } as *const _ as *const JSJitInfo },
21358 nargs: 2,
21359 flags: (JSPROP_ENUMERATE) as u16,
21360 selfHostedName: ptr::null()
21361 },
21362 JSFunctionSpec {
21363 name: JSPropertySpec_Name { string_: c"uniform4uiv".as_ptr() },
21364 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4uiv_methodinfo.get() } as *const _ as *const JSJitInfo },
21365 nargs: 2,
21366 flags: (JSPROP_ENUMERATE) as u16,
21367 selfHostedName: ptr::null()
21368 },
21369 JSFunctionSpec {
21370 name: JSPropertySpec_Name { string_: c"uniformMatrix3x2fv".as_ptr() },
21371 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix3x2fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21372 nargs: 3,
21373 flags: (JSPROP_ENUMERATE) as u16,
21374 selfHostedName: ptr::null()
21375 },
21376 JSFunctionSpec {
21377 name: JSPropertySpec_Name { string_: c"uniformMatrix4x2fv".as_ptr() },
21378 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix4x2fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21379 nargs: 3,
21380 flags: (JSPROP_ENUMERATE) as u16,
21381 selfHostedName: ptr::null()
21382 },
21383 JSFunctionSpec {
21384 name: JSPropertySpec_Name { string_: c"uniformMatrix2x3fv".as_ptr() },
21385 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix2x3fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21386 nargs: 3,
21387 flags: (JSPROP_ENUMERATE) as u16,
21388 selfHostedName: ptr::null()
21389 },
21390 JSFunctionSpec {
21391 name: JSPropertySpec_Name { string_: c"uniformMatrix4x3fv".as_ptr() },
21392 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix4x3fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21393 nargs: 3,
21394 flags: (JSPROP_ENUMERATE) as u16,
21395 selfHostedName: ptr::null()
21396 },
21397 JSFunctionSpec {
21398 name: JSPropertySpec_Name { string_: c"uniformMatrix2x4fv".as_ptr() },
21399 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix2x4fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21400 nargs: 3,
21401 flags: (JSPROP_ENUMERATE) as u16,
21402 selfHostedName: ptr::null()
21403 },
21404 JSFunctionSpec {
21405 name: JSPropertySpec_Name { string_: c"uniformMatrix3x4fv".as_ptr() },
21406 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix3x4fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21407 nargs: 3,
21408 flags: (JSPROP_ENUMERATE) as u16,
21409 selfHostedName: ptr::null()
21410 },
21411 JSFunctionSpec {
21412 name: JSPropertySpec_Name { string_: c"vertexAttribI4i".as_ptr() },
21413 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttribI4i_methodinfo.get() } as *const _ as *const JSJitInfo },
21414 nargs: 5,
21415 flags: (JSPROP_ENUMERATE) as u16,
21416 selfHostedName: ptr::null()
21417 },
21418 JSFunctionSpec {
21419 name: JSPropertySpec_Name { string_: c"vertexAttribI4iv".as_ptr() },
21420 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttribI4iv_methodinfo.get() } as *const _ as *const JSJitInfo },
21421 nargs: 2,
21422 flags: (JSPROP_ENUMERATE) as u16,
21423 selfHostedName: ptr::null()
21424 },
21425 JSFunctionSpec {
21426 name: JSPropertySpec_Name { string_: c"vertexAttribI4ui".as_ptr() },
21427 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttribI4ui_methodinfo.get() } as *const _ as *const JSJitInfo },
21428 nargs: 5,
21429 flags: (JSPROP_ENUMERATE) as u16,
21430 selfHostedName: ptr::null()
21431 },
21432 JSFunctionSpec {
21433 name: JSPropertySpec_Name { string_: c"vertexAttribI4uiv".as_ptr() },
21434 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttribI4uiv_methodinfo.get() } as *const _ as *const JSJitInfo },
21435 nargs: 2,
21436 flags: (JSPROP_ENUMERATE) as u16,
21437 selfHostedName: ptr::null()
21438 },
21439 JSFunctionSpec {
21440 name: JSPropertySpec_Name { string_: c"vertexAttribIPointer".as_ptr() },
21441 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttribIPointer_methodinfo.get() } as *const _ as *const JSJitInfo },
21442 nargs: 5,
21443 flags: (JSPROP_ENUMERATE) as u16,
21444 selfHostedName: ptr::null()
21445 },
21446 JSFunctionSpec {
21447 name: JSPropertySpec_Name { string_: c"vertexAttribDivisor".as_ptr() },
21448 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttribDivisor_methodinfo.get() } as *const _ as *const JSJitInfo },
21449 nargs: 2,
21450 flags: (JSPROP_ENUMERATE) as u16,
21451 selfHostedName: ptr::null()
21452 },
21453 JSFunctionSpec {
21454 name: JSPropertySpec_Name { string_: c"drawArraysInstanced".as_ptr() },
21455 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawArraysInstanced_methodinfo.get() } as *const _ as *const JSJitInfo },
21456 nargs: 4,
21457 flags: (JSPROP_ENUMERATE) as u16,
21458 selfHostedName: ptr::null()
21459 },
21460 JSFunctionSpec {
21461 name: JSPropertySpec_Name { string_: c"drawElementsInstanced".as_ptr() },
21462 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawElementsInstanced_methodinfo.get() } as *const _ as *const JSJitInfo },
21463 nargs: 5,
21464 flags: (JSPROP_ENUMERATE) as u16,
21465 selfHostedName: ptr::null()
21466 },
21467 JSFunctionSpec {
21468 name: JSPropertySpec_Name { string_: c"drawRangeElements".as_ptr() },
21469 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawRangeElements_methodinfo.get() } as *const _ as *const JSJitInfo },
21470 nargs: 6,
21471 flags: (JSPROP_ENUMERATE) as u16,
21472 selfHostedName: ptr::null()
21473 },
21474 JSFunctionSpec {
21475 name: JSPropertySpec_Name { string_: c"drawBuffers".as_ptr() },
21476 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawBuffers_methodinfo.get() } as *const _ as *const JSJitInfo },
21477 nargs: 1,
21478 flags: (JSPROP_ENUMERATE) as u16,
21479 selfHostedName: ptr::null()
21480 },
21481 JSFunctionSpec {
21482 name: JSPropertySpec_Name { string_: c"clearBufferfv".as_ptr() },
21483 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearBufferfv_methodinfo.get() } as *const _ as *const JSJitInfo },
21484 nargs: 3,
21485 flags: (JSPROP_ENUMERATE) as u16,
21486 selfHostedName: ptr::null()
21487 },
21488 JSFunctionSpec {
21489 name: JSPropertySpec_Name { string_: c"clearBufferiv".as_ptr() },
21490 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearBufferiv_methodinfo.get() } as *const _ as *const JSJitInfo },
21491 nargs: 3,
21492 flags: (JSPROP_ENUMERATE) as u16,
21493 selfHostedName: ptr::null()
21494 },
21495 JSFunctionSpec {
21496 name: JSPropertySpec_Name { string_: c"clearBufferuiv".as_ptr() },
21497 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearBufferuiv_methodinfo.get() } as *const _ as *const JSJitInfo },
21498 nargs: 3,
21499 flags: (JSPROP_ENUMERATE) as u16,
21500 selfHostedName: ptr::null()
21501 },
21502 JSFunctionSpec {
21503 name: JSPropertySpec_Name { string_: c"clearBufferfi".as_ptr() },
21504 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearBufferfi_methodinfo.get() } as *const _ as *const JSJitInfo },
21505 nargs: 4,
21506 flags: (JSPROP_ENUMERATE) as u16,
21507 selfHostedName: ptr::null()
21508 },
21509 JSFunctionSpec {
21510 name: JSPropertySpec_Name { string_: c"createQuery".as_ptr() },
21511 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createQuery_methodinfo.get() } as *const _ as *const JSJitInfo },
21512 nargs: 0,
21513 flags: (JSPROP_ENUMERATE) as u16,
21514 selfHostedName: ptr::null()
21515 },
21516 JSFunctionSpec {
21517 name: JSPropertySpec_Name { string_: c"deleteQuery".as_ptr() },
21518 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteQuery_methodinfo.get() } as *const _ as *const JSJitInfo },
21519 nargs: 1,
21520 flags: (JSPROP_ENUMERATE) as u16,
21521 selfHostedName: ptr::null()
21522 },
21523 JSFunctionSpec {
21524 name: JSPropertySpec_Name { string_: c"isQuery".as_ptr() },
21525 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isQuery_methodinfo.get() } as *const _ as *const JSJitInfo },
21526 nargs: 1,
21527 flags: (JSPROP_ENUMERATE) as u16,
21528 selfHostedName: ptr::null()
21529 },
21530 JSFunctionSpec {
21531 name: JSPropertySpec_Name { string_: c"beginQuery".as_ptr() },
21532 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { beginQuery_methodinfo.get() } as *const _ as *const JSJitInfo },
21533 nargs: 2,
21534 flags: (JSPROP_ENUMERATE) as u16,
21535 selfHostedName: ptr::null()
21536 },
21537 JSFunctionSpec {
21538 name: JSPropertySpec_Name { string_: c"endQuery".as_ptr() },
21539 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { endQuery_methodinfo.get() } as *const _ as *const JSJitInfo },
21540 nargs: 1,
21541 flags: (JSPROP_ENUMERATE) as u16,
21542 selfHostedName: ptr::null()
21543 },
21544 JSFunctionSpec {
21545 name: JSPropertySpec_Name { string_: c"getQuery".as_ptr() },
21546 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getQuery_methodinfo.get() } as *const _ as *const JSJitInfo },
21547 nargs: 2,
21548 flags: (JSPROP_ENUMERATE) as u16,
21549 selfHostedName: ptr::null()
21550 },
21551 JSFunctionSpec {
21552 name: JSPropertySpec_Name { string_: c"getQueryParameter".as_ptr() },
21553 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getQueryParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
21554 nargs: 2,
21555 flags: (JSPROP_ENUMERATE) as u16,
21556 selfHostedName: ptr::null()
21557 },
21558 JSFunctionSpec {
21559 name: JSPropertySpec_Name { string_: c"createSampler".as_ptr() },
21560 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createSampler_methodinfo.get() } as *const _ as *const JSJitInfo },
21561 nargs: 0,
21562 flags: (JSPROP_ENUMERATE) as u16,
21563 selfHostedName: ptr::null()
21564 },
21565 JSFunctionSpec {
21566 name: JSPropertySpec_Name { string_: c"deleteSampler".as_ptr() },
21567 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteSampler_methodinfo.get() } as *const _ as *const JSJitInfo },
21568 nargs: 1,
21569 flags: (JSPROP_ENUMERATE) as u16,
21570 selfHostedName: ptr::null()
21571 },
21572 JSFunctionSpec {
21573 name: JSPropertySpec_Name { string_: c"isSampler".as_ptr() },
21574 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isSampler_methodinfo.get() } as *const _ as *const JSJitInfo },
21575 nargs: 1,
21576 flags: (JSPROP_ENUMERATE) as u16,
21577 selfHostedName: ptr::null()
21578 },
21579 JSFunctionSpec {
21580 name: JSPropertySpec_Name { string_: c"bindSampler".as_ptr() },
21581 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindSampler_methodinfo.get() } as *const _ as *const JSJitInfo },
21582 nargs: 2,
21583 flags: (JSPROP_ENUMERATE) as u16,
21584 selfHostedName: ptr::null()
21585 },
21586 JSFunctionSpec {
21587 name: JSPropertySpec_Name { string_: c"samplerParameteri".as_ptr() },
21588 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { samplerParameteri_methodinfo.get() } as *const _ as *const JSJitInfo },
21589 nargs: 3,
21590 flags: (JSPROP_ENUMERATE) as u16,
21591 selfHostedName: ptr::null()
21592 },
21593 JSFunctionSpec {
21594 name: JSPropertySpec_Name { string_: c"samplerParameterf".as_ptr() },
21595 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { samplerParameterf_methodinfo.get() } as *const _ as *const JSJitInfo },
21596 nargs: 3,
21597 flags: (JSPROP_ENUMERATE) as u16,
21598 selfHostedName: ptr::null()
21599 },
21600 JSFunctionSpec {
21601 name: JSPropertySpec_Name { string_: c"getSamplerParameter".as_ptr() },
21602 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getSamplerParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
21603 nargs: 2,
21604 flags: (JSPROP_ENUMERATE) as u16,
21605 selfHostedName: ptr::null()
21606 },
21607 JSFunctionSpec {
21608 name: JSPropertySpec_Name { string_: c"fenceSync".as_ptr() },
21609 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { fenceSync_methodinfo.get() } as *const _ as *const JSJitInfo },
21610 nargs: 2,
21611 flags: (JSPROP_ENUMERATE) as u16,
21612 selfHostedName: ptr::null()
21613 },
21614 JSFunctionSpec {
21615 name: JSPropertySpec_Name { string_: c"isSync".as_ptr() },
21616 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isSync_methodinfo.get() } as *const _ as *const JSJitInfo },
21617 nargs: 1,
21618 flags: (JSPROP_ENUMERATE) as u16,
21619 selfHostedName: ptr::null()
21620 },
21621 JSFunctionSpec {
21622 name: JSPropertySpec_Name { string_: c"deleteSync".as_ptr() },
21623 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteSync_methodinfo.get() } as *const _ as *const JSJitInfo },
21624 nargs: 1,
21625 flags: (JSPROP_ENUMERATE) as u16,
21626 selfHostedName: ptr::null()
21627 },
21628 JSFunctionSpec {
21629 name: JSPropertySpec_Name { string_: c"clientWaitSync".as_ptr() },
21630 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clientWaitSync_methodinfo.get() } as *const _ as *const JSJitInfo },
21631 nargs: 3,
21632 flags: (JSPROP_ENUMERATE) as u16,
21633 selfHostedName: ptr::null()
21634 },
21635 JSFunctionSpec {
21636 name: JSPropertySpec_Name { string_: c"waitSync".as_ptr() },
21637 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { waitSync_methodinfo.get() } as *const _ as *const JSJitInfo },
21638 nargs: 3,
21639 flags: (JSPROP_ENUMERATE) as u16,
21640 selfHostedName: ptr::null()
21641 },
21642 JSFunctionSpec {
21643 name: JSPropertySpec_Name { string_: c"getSyncParameter".as_ptr() },
21644 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getSyncParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
21645 nargs: 2,
21646 flags: (JSPROP_ENUMERATE) as u16,
21647 selfHostedName: ptr::null()
21648 },
21649 JSFunctionSpec {
21650 name: JSPropertySpec_Name { string_: c"createTransformFeedback".as_ptr() },
21651 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createTransformFeedback_methodinfo.get() } as *const _ as *const JSJitInfo },
21652 nargs: 0,
21653 flags: (JSPROP_ENUMERATE) as u16,
21654 selfHostedName: ptr::null()
21655 },
21656 JSFunctionSpec {
21657 name: JSPropertySpec_Name { string_: c"deleteTransformFeedback".as_ptr() },
21658 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteTransformFeedback_methodinfo.get() } as *const _ as *const JSJitInfo },
21659 nargs: 1,
21660 flags: (JSPROP_ENUMERATE) as u16,
21661 selfHostedName: ptr::null()
21662 },
21663 JSFunctionSpec {
21664 name: JSPropertySpec_Name { string_: c"isTransformFeedback".as_ptr() },
21665 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isTransformFeedback_methodinfo.get() } as *const _ as *const JSJitInfo },
21666 nargs: 1,
21667 flags: (JSPROP_ENUMERATE) as u16,
21668 selfHostedName: ptr::null()
21669 },
21670 JSFunctionSpec {
21671 name: JSPropertySpec_Name { string_: c"bindTransformFeedback".as_ptr() },
21672 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindTransformFeedback_methodinfo.get() } as *const _ as *const JSJitInfo },
21673 nargs: 2,
21674 flags: (JSPROP_ENUMERATE) as u16,
21675 selfHostedName: ptr::null()
21676 },
21677 JSFunctionSpec {
21678 name: JSPropertySpec_Name { string_: c"beginTransformFeedback".as_ptr() },
21679 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { beginTransformFeedback_methodinfo.get() } as *const _ as *const JSJitInfo },
21680 nargs: 1,
21681 flags: (JSPROP_ENUMERATE) as u16,
21682 selfHostedName: ptr::null()
21683 },
21684 JSFunctionSpec {
21685 name: JSPropertySpec_Name { string_: c"endTransformFeedback".as_ptr() },
21686 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { endTransformFeedback_methodinfo.get() } as *const _ as *const JSJitInfo },
21687 nargs: 0,
21688 flags: (JSPROP_ENUMERATE) as u16,
21689 selfHostedName: ptr::null()
21690 },
21691 JSFunctionSpec {
21692 name: JSPropertySpec_Name { string_: c"transformFeedbackVaryings".as_ptr() },
21693 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { transformFeedbackVaryings_methodinfo.get() } as *const _ as *const JSJitInfo },
21694 nargs: 3,
21695 flags: (JSPROP_ENUMERATE) as u16,
21696 selfHostedName: ptr::null()
21697 },
21698 JSFunctionSpec {
21699 name: JSPropertySpec_Name { string_: c"getTransformFeedbackVarying".as_ptr() },
21700 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getTransformFeedbackVarying_methodinfo.get() } as *const _ as *const JSJitInfo },
21701 nargs: 2,
21702 flags: (JSPROP_ENUMERATE) as u16,
21703 selfHostedName: ptr::null()
21704 },
21705 JSFunctionSpec {
21706 name: JSPropertySpec_Name { string_: c"pauseTransformFeedback".as_ptr() },
21707 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { pauseTransformFeedback_methodinfo.get() } as *const _ as *const JSJitInfo },
21708 nargs: 0,
21709 flags: (JSPROP_ENUMERATE) as u16,
21710 selfHostedName: ptr::null()
21711 },
21712 JSFunctionSpec {
21713 name: JSPropertySpec_Name { string_: c"resumeTransformFeedback".as_ptr() },
21714 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { resumeTransformFeedback_methodinfo.get() } as *const _ as *const JSJitInfo },
21715 nargs: 0,
21716 flags: (JSPROP_ENUMERATE) as u16,
21717 selfHostedName: ptr::null()
21718 },
21719 JSFunctionSpec {
21720 name: JSPropertySpec_Name { string_: c"bindBufferBase".as_ptr() },
21721 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindBufferBase_methodinfo.get() } as *const _ as *const JSJitInfo },
21722 nargs: 3,
21723 flags: (JSPROP_ENUMERATE) as u16,
21724 selfHostedName: ptr::null()
21725 },
21726 JSFunctionSpec {
21727 name: JSPropertySpec_Name { string_: c"bindBufferRange".as_ptr() },
21728 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindBufferRange_methodinfo.get() } as *const _ as *const JSJitInfo },
21729 nargs: 5,
21730 flags: (JSPROP_ENUMERATE) as u16,
21731 selfHostedName: ptr::null()
21732 },
21733 JSFunctionSpec {
21734 name: JSPropertySpec_Name { string_: c"getIndexedParameter".as_ptr() },
21735 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getIndexedParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
21736 nargs: 2,
21737 flags: (JSPROP_ENUMERATE) as u16,
21738 selfHostedName: ptr::null()
21739 },
21740 JSFunctionSpec {
21741 name: JSPropertySpec_Name { string_: c"getUniformIndices".as_ptr() },
21742 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getUniformIndices_methodinfo.get() } as *const _ as *const JSJitInfo },
21743 nargs: 2,
21744 flags: (JSPROP_ENUMERATE) as u16,
21745 selfHostedName: ptr::null()
21746 },
21747 JSFunctionSpec {
21748 name: JSPropertySpec_Name { string_: c"getActiveUniforms".as_ptr() },
21749 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getActiveUniforms_methodinfo.get() } as *const _ as *const JSJitInfo },
21750 nargs: 3,
21751 flags: (JSPROP_ENUMERATE) as u16,
21752 selfHostedName: ptr::null()
21753 },
21754 JSFunctionSpec {
21755 name: JSPropertySpec_Name { string_: c"getUniformBlockIndex".as_ptr() },
21756 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getUniformBlockIndex_methodinfo.get() } as *const _ as *const JSJitInfo },
21757 nargs: 2,
21758 flags: (JSPROP_ENUMERATE) as u16,
21759 selfHostedName: ptr::null()
21760 },
21761 JSFunctionSpec {
21762 name: JSPropertySpec_Name { string_: c"getActiveUniformBlockParameter".as_ptr() },
21763 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getActiveUniformBlockParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
21764 nargs: 3,
21765 flags: (JSPROP_ENUMERATE) as u16,
21766 selfHostedName: ptr::null()
21767 },
21768 JSFunctionSpec {
21769 name: JSPropertySpec_Name { string_: c"getActiveUniformBlockName".as_ptr() },
21770 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getActiveUniformBlockName_methodinfo.get() } as *const _ as *const JSJitInfo },
21771 nargs: 2,
21772 flags: (JSPROP_ENUMERATE) as u16,
21773 selfHostedName: ptr::null()
21774 },
21775 JSFunctionSpec {
21776 name: JSPropertySpec_Name { string_: c"uniformBlockBinding".as_ptr() },
21777 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformBlockBinding_methodinfo.get() } as *const _ as *const JSJitInfo },
21778 nargs: 3,
21779 flags: (JSPROP_ENUMERATE) as u16,
21780 selfHostedName: ptr::null()
21781 },
21782 JSFunctionSpec {
21783 name: JSPropertySpec_Name { string_: c"createVertexArray".as_ptr() },
21784 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createVertexArray_methodinfo.get() } as *const _ as *const JSJitInfo },
21785 nargs: 0,
21786 flags: (JSPROP_ENUMERATE) as u16,
21787 selfHostedName: ptr::null()
21788 },
21789 JSFunctionSpec {
21790 name: JSPropertySpec_Name { string_: c"deleteVertexArray".as_ptr() },
21791 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteVertexArray_methodinfo.get() } as *const _ as *const JSJitInfo },
21792 nargs: 1,
21793 flags: (JSPROP_ENUMERATE) as u16,
21794 selfHostedName: ptr::null()
21795 },
21796 JSFunctionSpec {
21797 name: JSPropertySpec_Name { string_: c"isVertexArray".as_ptr() },
21798 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isVertexArray_methodinfo.get() } as *const _ as *const JSJitInfo },
21799 nargs: 1,
21800 flags: (JSPROP_ENUMERATE) as u16,
21801 selfHostedName: ptr::null()
21802 },
21803 JSFunctionSpec {
21804 name: JSPropertySpec_Name { string_: c"bindVertexArray".as_ptr() },
21805 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindVertexArray_methodinfo.get() } as *const _ as *const JSJitInfo },
21806 nargs: 1,
21807 flags: (JSPROP_ENUMERATE) as u16,
21808 selfHostedName: ptr::null()
21809 },
21810 JSFunctionSpec {
21811 name: JSPropertySpec_Name { string_: c"bufferData".as_ptr() },
21812 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bufferData_methodinfo.get() } as *const _ as *const JSJitInfo },
21813 nargs: 3,
21814 flags: (JSPROP_ENUMERATE) as u16,
21815 selfHostedName: ptr::null()
21816 },
21817 JSFunctionSpec {
21818 name: JSPropertySpec_Name { string_: c"bufferSubData".as_ptr() },
21819 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bufferSubData_methodinfo.get() } as *const _ as *const JSJitInfo },
21820 nargs: 3,
21821 flags: (JSPROP_ENUMERATE) as u16,
21822 selfHostedName: ptr::null()
21823 },
21824 JSFunctionSpec {
21825 name: JSPropertySpec_Name { string_: c"texImage2D".as_ptr() },
21826 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
21827 nargs: 6,
21828 flags: (JSPROP_ENUMERATE) as u16,
21829 selfHostedName: ptr::null()
21830 },
21831 JSFunctionSpec {
21832 name: JSPropertySpec_Name { string_: c"texSubImage2D".as_ptr() },
21833 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texSubImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
21834 nargs: 7,
21835 flags: (JSPROP_ENUMERATE) as u16,
21836 selfHostedName: ptr::null()
21837 },
21838 JSFunctionSpec {
21839 name: JSPropertySpec_Name { string_: c"compressedTexImage2D".as_ptr() },
21840 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { compressedTexImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
21841 nargs: 7,
21842 flags: (JSPROP_ENUMERATE) as u16,
21843 selfHostedName: ptr::null()
21844 },
21845 JSFunctionSpec {
21846 name: JSPropertySpec_Name { string_: c"compressedTexSubImage2D".as_ptr() },
21847 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { compressedTexSubImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
21848 nargs: 8,
21849 flags: (JSPROP_ENUMERATE) as u16,
21850 selfHostedName: ptr::null()
21851 },
21852 JSFunctionSpec {
21853 name: JSPropertySpec_Name { string_: c"uniform1fv".as_ptr() },
21854 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21855 nargs: 2,
21856 flags: (JSPROP_ENUMERATE) as u16,
21857 selfHostedName: ptr::null()
21858 },
21859 JSFunctionSpec {
21860 name: JSPropertySpec_Name { string_: c"uniform2fv".as_ptr() },
21861 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21862 nargs: 2,
21863 flags: (JSPROP_ENUMERATE) as u16,
21864 selfHostedName: ptr::null()
21865 },
21866 JSFunctionSpec {
21867 name: JSPropertySpec_Name { string_: c"uniform3fv".as_ptr() },
21868 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21869 nargs: 2,
21870 flags: (JSPROP_ENUMERATE) as u16,
21871 selfHostedName: ptr::null()
21872 },
21873 JSFunctionSpec {
21874 name: JSPropertySpec_Name { string_: c"uniform4fv".as_ptr() },
21875 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21876 nargs: 2,
21877 flags: (JSPROP_ENUMERATE) as u16,
21878 selfHostedName: ptr::null()
21879 },
21880 JSFunctionSpec {
21881 name: JSPropertySpec_Name { string_: c"uniform1iv".as_ptr() },
21882 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1iv_methodinfo.get() } as *const _ as *const JSJitInfo },
21883 nargs: 2,
21884 flags: (JSPROP_ENUMERATE) as u16,
21885 selfHostedName: ptr::null()
21886 },
21887 JSFunctionSpec {
21888 name: JSPropertySpec_Name { string_: c"uniform2iv".as_ptr() },
21889 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2iv_methodinfo.get() } as *const _ as *const JSJitInfo },
21890 nargs: 2,
21891 flags: (JSPROP_ENUMERATE) as u16,
21892 selfHostedName: ptr::null()
21893 },
21894 JSFunctionSpec {
21895 name: JSPropertySpec_Name { string_: c"uniform3iv".as_ptr() },
21896 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3iv_methodinfo.get() } as *const _ as *const JSJitInfo },
21897 nargs: 2,
21898 flags: (JSPROP_ENUMERATE) as u16,
21899 selfHostedName: ptr::null()
21900 },
21901 JSFunctionSpec {
21902 name: JSPropertySpec_Name { string_: c"uniform4iv".as_ptr() },
21903 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4iv_methodinfo.get() } as *const _ as *const JSJitInfo },
21904 nargs: 2,
21905 flags: (JSPROP_ENUMERATE) as u16,
21906 selfHostedName: ptr::null()
21907 },
21908 JSFunctionSpec {
21909 name: JSPropertySpec_Name { string_: c"uniformMatrix2fv".as_ptr() },
21910 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix2fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21911 nargs: 3,
21912 flags: (JSPROP_ENUMERATE) as u16,
21913 selfHostedName: ptr::null()
21914 },
21915 JSFunctionSpec {
21916 name: JSPropertySpec_Name { string_: c"uniformMatrix3fv".as_ptr() },
21917 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix3fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21918 nargs: 3,
21919 flags: (JSPROP_ENUMERATE) as u16,
21920 selfHostedName: ptr::null()
21921 },
21922 JSFunctionSpec {
21923 name: JSPropertySpec_Name { string_: c"uniformMatrix4fv".as_ptr() },
21924 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix4fv_methodinfo.get() } as *const _ as *const JSJitInfo },
21925 nargs: 3,
21926 flags: (JSPROP_ENUMERATE) as u16,
21927 selfHostedName: ptr::null()
21928 },
21929 JSFunctionSpec {
21930 name: JSPropertySpec_Name { string_: c"readPixels".as_ptr() },
21931 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { readPixels_methodinfo.get() } as *const _ as *const JSJitInfo },
21932 nargs: 7,
21933 flags: (JSPROP_ENUMERATE) as u16,
21934 selfHostedName: ptr::null()
21935 },
21936 JSFunctionSpec {
21937 name: JSPropertySpec_Name { string_: ptr::null() },
21938 call: JSNativeWrapper { op: None, info: ptr::null() },
21939 nargs: 0,
21940 flags: 0,
21941 selfHostedName: ptr::null()
21942 }]))[..]
21943,
21944&Box::leak(Box::new([
21945 JSFunctionSpec {
21946 name: JSPropertySpec_Name { string_: c"getContextAttributes".as_ptr() },
21947 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getContextAttributes_methodinfo.get() } as *const _ as *const JSJitInfo },
21948 nargs: 0,
21949 flags: (JSPROP_ENUMERATE) as u16,
21950 selfHostedName: ptr::null()
21951 },
21952 JSFunctionSpec {
21953 name: JSPropertySpec_Name { string_: c"isContextLost".as_ptr() },
21954 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isContextLost_methodinfo.get() } as *const _ as *const JSJitInfo },
21955 nargs: 0,
21956 flags: (JSPROP_ENUMERATE) as u16,
21957 selfHostedName: ptr::null()
21958 },
21959 JSFunctionSpec {
21960 name: JSPropertySpec_Name { string_: c"getSupportedExtensions".as_ptr() },
21961 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getSupportedExtensions_methodinfo.get() } as *const _ as *const JSJitInfo },
21962 nargs: 0,
21963 flags: (JSPROP_ENUMERATE) as u16,
21964 selfHostedName: ptr::null()
21965 },
21966 JSFunctionSpec {
21967 name: JSPropertySpec_Name { string_: c"getExtension".as_ptr() },
21968 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getExtension_methodinfo.get() } as *const _ as *const JSJitInfo },
21969 nargs: 1,
21970 flags: (JSPROP_ENUMERATE) as u16,
21971 selfHostedName: ptr::null()
21972 },
21973 JSFunctionSpec {
21974 name: JSPropertySpec_Name { string_: c"activeTexture".as_ptr() },
21975 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { activeTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
21976 nargs: 1,
21977 flags: (JSPROP_ENUMERATE) as u16,
21978 selfHostedName: ptr::null()
21979 },
21980 JSFunctionSpec {
21981 name: JSPropertySpec_Name { string_: c"attachShader".as_ptr() },
21982 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { attachShader_methodinfo.get() } as *const _ as *const JSJitInfo },
21983 nargs: 2,
21984 flags: (JSPROP_ENUMERATE) as u16,
21985 selfHostedName: ptr::null()
21986 },
21987 JSFunctionSpec {
21988 name: JSPropertySpec_Name { string_: c"bindAttribLocation".as_ptr() },
21989 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindAttribLocation_methodinfo.get() } as *const _ as *const JSJitInfo },
21990 nargs: 3,
21991 flags: (JSPROP_ENUMERATE) as u16,
21992 selfHostedName: ptr::null()
21993 },
21994 JSFunctionSpec {
21995 name: JSPropertySpec_Name { string_: c"bindBuffer".as_ptr() },
21996 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
21997 nargs: 2,
21998 flags: (JSPROP_ENUMERATE) as u16,
21999 selfHostedName: ptr::null()
22000 },
22001 JSFunctionSpec {
22002 name: JSPropertySpec_Name { string_: c"bindFramebuffer".as_ptr() },
22003 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22004 nargs: 2,
22005 flags: (JSPROP_ENUMERATE) as u16,
22006 selfHostedName: ptr::null()
22007 },
22008 JSFunctionSpec {
22009 name: JSPropertySpec_Name { string_: c"bindRenderbuffer".as_ptr() },
22010 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22011 nargs: 2,
22012 flags: (JSPROP_ENUMERATE) as u16,
22013 selfHostedName: ptr::null()
22014 },
22015 JSFunctionSpec {
22016 name: JSPropertySpec_Name { string_: c"bindTexture".as_ptr() },
22017 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
22018 nargs: 2,
22019 flags: (JSPROP_ENUMERATE) as u16,
22020 selfHostedName: ptr::null()
22021 },
22022 JSFunctionSpec {
22023 name: JSPropertySpec_Name { string_: c"blendColor".as_ptr() },
22024 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendColor_methodinfo.get() } as *const _ as *const JSJitInfo },
22025 nargs: 4,
22026 flags: (JSPROP_ENUMERATE) as u16,
22027 selfHostedName: ptr::null()
22028 },
22029 JSFunctionSpec {
22030 name: JSPropertySpec_Name { string_: c"blendEquation".as_ptr() },
22031 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendEquation_methodinfo.get() } as *const _ as *const JSJitInfo },
22032 nargs: 1,
22033 flags: (JSPROP_ENUMERATE) as u16,
22034 selfHostedName: ptr::null()
22035 },
22036 JSFunctionSpec {
22037 name: JSPropertySpec_Name { string_: c"blendEquationSeparate".as_ptr() },
22038 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendEquationSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
22039 nargs: 2,
22040 flags: (JSPROP_ENUMERATE) as u16,
22041 selfHostedName: ptr::null()
22042 },
22043 JSFunctionSpec {
22044 name: JSPropertySpec_Name { string_: c"blendFunc".as_ptr() },
22045 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendFunc_methodinfo.get() } as *const _ as *const JSJitInfo },
22046 nargs: 2,
22047 flags: (JSPROP_ENUMERATE) as u16,
22048 selfHostedName: ptr::null()
22049 },
22050 JSFunctionSpec {
22051 name: JSPropertySpec_Name { string_: c"blendFuncSeparate".as_ptr() },
22052 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendFuncSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
22053 nargs: 4,
22054 flags: (JSPROP_ENUMERATE) as u16,
22055 selfHostedName: ptr::null()
22056 },
22057 JSFunctionSpec {
22058 name: JSPropertySpec_Name { string_: c"checkFramebufferStatus".as_ptr() },
22059 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { checkFramebufferStatus_methodinfo.get() } as *const _ as *const JSJitInfo },
22060 nargs: 1,
22061 flags: (JSPROP_ENUMERATE) as u16,
22062 selfHostedName: ptr::null()
22063 },
22064 JSFunctionSpec {
22065 name: JSPropertySpec_Name { string_: c"clear".as_ptr() },
22066 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clear_methodinfo.get() } as *const _ as *const JSJitInfo },
22067 nargs: 1,
22068 flags: (JSPROP_ENUMERATE) as u16,
22069 selfHostedName: ptr::null()
22070 },
22071 JSFunctionSpec {
22072 name: JSPropertySpec_Name { string_: c"clearColor".as_ptr() },
22073 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearColor_methodinfo.get() } as *const _ as *const JSJitInfo },
22074 nargs: 4,
22075 flags: (JSPROP_ENUMERATE) as u16,
22076 selfHostedName: ptr::null()
22077 },
22078 JSFunctionSpec {
22079 name: JSPropertySpec_Name { string_: c"clearDepth".as_ptr() },
22080 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearDepth_methodinfo.get() } as *const _ as *const JSJitInfo },
22081 nargs: 1,
22082 flags: (JSPROP_ENUMERATE) as u16,
22083 selfHostedName: ptr::null()
22084 },
22085 JSFunctionSpec {
22086 name: JSPropertySpec_Name { string_: c"clearStencil".as_ptr() },
22087 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearStencil_methodinfo.get() } as *const _ as *const JSJitInfo },
22088 nargs: 1,
22089 flags: (JSPROP_ENUMERATE) as u16,
22090 selfHostedName: ptr::null()
22091 },
22092 JSFunctionSpec {
22093 name: JSPropertySpec_Name { string_: c"colorMask".as_ptr() },
22094 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { colorMask_methodinfo.get() } as *const _ as *const JSJitInfo },
22095 nargs: 4,
22096 flags: (JSPROP_ENUMERATE) as u16,
22097 selfHostedName: ptr::null()
22098 },
22099 JSFunctionSpec {
22100 name: JSPropertySpec_Name { string_: c"compileShader".as_ptr() },
22101 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { compileShader_methodinfo.get() } as *const _ as *const JSJitInfo },
22102 nargs: 1,
22103 flags: (JSPROP_ENUMERATE) as u16,
22104 selfHostedName: ptr::null()
22105 },
22106 JSFunctionSpec {
22107 name: JSPropertySpec_Name { string_: c"copyTexImage2D".as_ptr() },
22108 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyTexImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
22109 nargs: 8,
22110 flags: (JSPROP_ENUMERATE) as u16,
22111 selfHostedName: ptr::null()
22112 },
22113 JSFunctionSpec {
22114 name: JSPropertySpec_Name { string_: c"copyTexSubImage2D".as_ptr() },
22115 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyTexSubImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
22116 nargs: 8,
22117 flags: (JSPROP_ENUMERATE) as u16,
22118 selfHostedName: ptr::null()
22119 },
22120 JSFunctionSpec {
22121 name: JSPropertySpec_Name { string_: c"createBuffer".as_ptr() },
22122 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22123 nargs: 0,
22124 flags: (JSPROP_ENUMERATE) as u16,
22125 selfHostedName: ptr::null()
22126 },
22127 JSFunctionSpec {
22128 name: JSPropertySpec_Name { string_: c"createFramebuffer".as_ptr() },
22129 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22130 nargs: 0,
22131 flags: (JSPROP_ENUMERATE) as u16,
22132 selfHostedName: ptr::null()
22133 },
22134 JSFunctionSpec {
22135 name: JSPropertySpec_Name { string_: c"createProgram".as_ptr() },
22136 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
22137 nargs: 0,
22138 flags: (JSPROP_ENUMERATE) as u16,
22139 selfHostedName: ptr::null()
22140 },
22141 JSFunctionSpec {
22142 name: JSPropertySpec_Name { string_: c"createRenderbuffer".as_ptr() },
22143 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22144 nargs: 0,
22145 flags: (JSPROP_ENUMERATE) as u16,
22146 selfHostedName: ptr::null()
22147 },
22148 JSFunctionSpec {
22149 name: JSPropertySpec_Name { string_: c"createShader".as_ptr() },
22150 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createShader_methodinfo.get() } as *const _ as *const JSJitInfo },
22151 nargs: 1,
22152 flags: (JSPROP_ENUMERATE) as u16,
22153 selfHostedName: ptr::null()
22154 },
22155 JSFunctionSpec {
22156 name: JSPropertySpec_Name { string_: c"createTexture".as_ptr() },
22157 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
22158 nargs: 0,
22159 flags: (JSPROP_ENUMERATE) as u16,
22160 selfHostedName: ptr::null()
22161 },
22162 JSFunctionSpec {
22163 name: JSPropertySpec_Name { string_: c"cullFace".as_ptr() },
22164 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { cullFace_methodinfo.get() } as *const _ as *const JSJitInfo },
22165 nargs: 1,
22166 flags: (JSPROP_ENUMERATE) as u16,
22167 selfHostedName: ptr::null()
22168 },
22169 JSFunctionSpec {
22170 name: JSPropertySpec_Name { string_: c"deleteBuffer".as_ptr() },
22171 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22172 nargs: 1,
22173 flags: (JSPROP_ENUMERATE) as u16,
22174 selfHostedName: ptr::null()
22175 },
22176 JSFunctionSpec {
22177 name: JSPropertySpec_Name { string_: c"deleteFramebuffer".as_ptr() },
22178 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22179 nargs: 1,
22180 flags: (JSPROP_ENUMERATE) as u16,
22181 selfHostedName: ptr::null()
22182 },
22183 JSFunctionSpec {
22184 name: JSPropertySpec_Name { string_: c"deleteProgram".as_ptr() },
22185 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
22186 nargs: 1,
22187 flags: (JSPROP_ENUMERATE) as u16,
22188 selfHostedName: ptr::null()
22189 },
22190 JSFunctionSpec {
22191 name: JSPropertySpec_Name { string_: c"deleteRenderbuffer".as_ptr() },
22192 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22193 nargs: 1,
22194 flags: (JSPROP_ENUMERATE) as u16,
22195 selfHostedName: ptr::null()
22196 },
22197 JSFunctionSpec {
22198 name: JSPropertySpec_Name { string_: c"deleteShader".as_ptr() },
22199 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteShader_methodinfo.get() } as *const _ as *const JSJitInfo },
22200 nargs: 1,
22201 flags: (JSPROP_ENUMERATE) as u16,
22202 selfHostedName: ptr::null()
22203 },
22204 JSFunctionSpec {
22205 name: JSPropertySpec_Name { string_: c"deleteTexture".as_ptr() },
22206 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
22207 nargs: 1,
22208 flags: (JSPROP_ENUMERATE) as u16,
22209 selfHostedName: ptr::null()
22210 },
22211 JSFunctionSpec {
22212 name: JSPropertySpec_Name { string_: c"depthFunc".as_ptr() },
22213 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { depthFunc_methodinfo.get() } as *const _ as *const JSJitInfo },
22214 nargs: 1,
22215 flags: (JSPROP_ENUMERATE) as u16,
22216 selfHostedName: ptr::null()
22217 },
22218 JSFunctionSpec {
22219 name: JSPropertySpec_Name { string_: c"depthMask".as_ptr() },
22220 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { depthMask_methodinfo.get() } as *const _ as *const JSJitInfo },
22221 nargs: 1,
22222 flags: (JSPROP_ENUMERATE) as u16,
22223 selfHostedName: ptr::null()
22224 },
22225 JSFunctionSpec {
22226 name: JSPropertySpec_Name { string_: c"depthRange".as_ptr() },
22227 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { depthRange_methodinfo.get() } as *const _ as *const JSJitInfo },
22228 nargs: 2,
22229 flags: (JSPROP_ENUMERATE) as u16,
22230 selfHostedName: ptr::null()
22231 },
22232 JSFunctionSpec {
22233 name: JSPropertySpec_Name { string_: c"detachShader".as_ptr() },
22234 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { detachShader_methodinfo.get() } as *const _ as *const JSJitInfo },
22235 nargs: 2,
22236 flags: (JSPROP_ENUMERATE) as u16,
22237 selfHostedName: ptr::null()
22238 },
22239 JSFunctionSpec {
22240 name: JSPropertySpec_Name { string_: c"disable".as_ptr() },
22241 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { disable_methodinfo.get() } as *const _ as *const JSJitInfo },
22242 nargs: 1,
22243 flags: (JSPROP_ENUMERATE) as u16,
22244 selfHostedName: ptr::null()
22245 },
22246 JSFunctionSpec {
22247 name: JSPropertySpec_Name { string_: c"disableVertexAttribArray".as_ptr() },
22248 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { disableVertexAttribArray_methodinfo.get() } as *const _ as *const JSJitInfo },
22249 nargs: 1,
22250 flags: (JSPROP_ENUMERATE) as u16,
22251 selfHostedName: ptr::null()
22252 },
22253 JSFunctionSpec {
22254 name: JSPropertySpec_Name { string_: c"drawArrays".as_ptr() },
22255 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawArrays_methodinfo.get() } as *const _ as *const JSJitInfo },
22256 nargs: 3,
22257 flags: (JSPROP_ENUMERATE) as u16,
22258 selfHostedName: ptr::null()
22259 },
22260 JSFunctionSpec {
22261 name: JSPropertySpec_Name { string_: c"drawElements".as_ptr() },
22262 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawElements_methodinfo.get() } as *const _ as *const JSJitInfo },
22263 nargs: 4,
22264 flags: (JSPROP_ENUMERATE) as u16,
22265 selfHostedName: ptr::null()
22266 },
22267 JSFunctionSpec {
22268 name: JSPropertySpec_Name { string_: c"enable".as_ptr() },
22269 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { enable_methodinfo.get() } as *const _ as *const JSJitInfo },
22270 nargs: 1,
22271 flags: (JSPROP_ENUMERATE) as u16,
22272 selfHostedName: ptr::null()
22273 },
22274 JSFunctionSpec {
22275 name: JSPropertySpec_Name { string_: c"enableVertexAttribArray".as_ptr() },
22276 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { enableVertexAttribArray_methodinfo.get() } as *const _ as *const JSJitInfo },
22277 nargs: 1,
22278 flags: (JSPROP_ENUMERATE) as u16,
22279 selfHostedName: ptr::null()
22280 },
22281 JSFunctionSpec {
22282 name: JSPropertySpec_Name { string_: c"finish".as_ptr() },
22283 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { finish_methodinfo.get() } as *const _ as *const JSJitInfo },
22284 nargs: 0,
22285 flags: (JSPROP_ENUMERATE) as u16,
22286 selfHostedName: ptr::null()
22287 },
22288 JSFunctionSpec {
22289 name: JSPropertySpec_Name { string_: c"flush".as_ptr() },
22290 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { flush_methodinfo.get() } as *const _ as *const JSJitInfo },
22291 nargs: 0,
22292 flags: (JSPROP_ENUMERATE) as u16,
22293 selfHostedName: ptr::null()
22294 },
22295 JSFunctionSpec {
22296 name: JSPropertySpec_Name { string_: c"framebufferRenderbuffer".as_ptr() },
22297 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { framebufferRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22298 nargs: 4,
22299 flags: (JSPROP_ENUMERATE) as u16,
22300 selfHostedName: ptr::null()
22301 },
22302 JSFunctionSpec {
22303 name: JSPropertySpec_Name { string_: c"framebufferTexture2D".as_ptr() },
22304 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { framebufferTexture2D_methodinfo.get() } as *const _ as *const JSJitInfo },
22305 nargs: 5,
22306 flags: (JSPROP_ENUMERATE) as u16,
22307 selfHostedName: ptr::null()
22308 },
22309 JSFunctionSpec {
22310 name: JSPropertySpec_Name { string_: c"frontFace".as_ptr() },
22311 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { frontFace_methodinfo.get() } as *const _ as *const JSJitInfo },
22312 nargs: 1,
22313 flags: (JSPROP_ENUMERATE) as u16,
22314 selfHostedName: ptr::null()
22315 },
22316 JSFunctionSpec {
22317 name: JSPropertySpec_Name { string_: c"generateMipmap".as_ptr() },
22318 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { generateMipmap_methodinfo.get() } as *const _ as *const JSJitInfo },
22319 nargs: 1,
22320 flags: (JSPROP_ENUMERATE) as u16,
22321 selfHostedName: ptr::null()
22322 },
22323 JSFunctionSpec {
22324 name: JSPropertySpec_Name { string_: c"getActiveAttrib".as_ptr() },
22325 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getActiveAttrib_methodinfo.get() } as *const _ as *const JSJitInfo },
22326 nargs: 2,
22327 flags: (JSPROP_ENUMERATE) as u16,
22328 selfHostedName: ptr::null()
22329 },
22330 JSFunctionSpec {
22331 name: JSPropertySpec_Name { string_: c"getActiveUniform".as_ptr() },
22332 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getActiveUniform_methodinfo.get() } as *const _ as *const JSJitInfo },
22333 nargs: 2,
22334 flags: (JSPROP_ENUMERATE) as u16,
22335 selfHostedName: ptr::null()
22336 },
22337 JSFunctionSpec {
22338 name: JSPropertySpec_Name { string_: c"getAttachedShaders".as_ptr() },
22339 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getAttachedShaders_methodinfo.get() } as *const _ as *const JSJitInfo },
22340 nargs: 1,
22341 flags: (JSPROP_ENUMERATE) as u16,
22342 selfHostedName: ptr::null()
22343 },
22344 JSFunctionSpec {
22345 name: JSPropertySpec_Name { string_: c"getAttribLocation".as_ptr() },
22346 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getAttribLocation_methodinfo.get() } as *const _ as *const JSJitInfo },
22347 nargs: 2,
22348 flags: (JSPROP_ENUMERATE) as u16,
22349 selfHostedName: ptr::null()
22350 },
22351 JSFunctionSpec {
22352 name: JSPropertySpec_Name { string_: c"getBufferParameter".as_ptr() },
22353 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getBufferParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
22354 nargs: 2,
22355 flags: (JSPROP_ENUMERATE) as u16,
22356 selfHostedName: ptr::null()
22357 },
22358 JSFunctionSpec {
22359 name: JSPropertySpec_Name { string_: c"getParameter".as_ptr() },
22360 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
22361 nargs: 1,
22362 flags: (JSPROP_ENUMERATE) as u16,
22363 selfHostedName: ptr::null()
22364 },
22365 JSFunctionSpec {
22366 name: JSPropertySpec_Name { string_: c"getError".as_ptr() },
22367 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getError_methodinfo.get() } as *const _ as *const JSJitInfo },
22368 nargs: 0,
22369 flags: (JSPROP_ENUMERATE) as u16,
22370 selfHostedName: ptr::null()
22371 },
22372 JSFunctionSpec {
22373 name: JSPropertySpec_Name { string_: c"getFramebufferAttachmentParameter".as_ptr() },
22374 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getFramebufferAttachmentParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
22375 nargs: 3,
22376 flags: (JSPROP_ENUMERATE) as u16,
22377 selfHostedName: ptr::null()
22378 },
22379 JSFunctionSpec {
22380 name: JSPropertySpec_Name { string_: c"getProgramParameter".as_ptr() },
22381 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getProgramParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
22382 nargs: 2,
22383 flags: (JSPROP_ENUMERATE) as u16,
22384 selfHostedName: ptr::null()
22385 },
22386 JSFunctionSpec {
22387 name: JSPropertySpec_Name { string_: c"getProgramInfoLog".as_ptr() },
22388 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getProgramInfoLog_methodinfo.get() } as *const _ as *const JSJitInfo },
22389 nargs: 1,
22390 flags: (JSPROP_ENUMERATE) as u16,
22391 selfHostedName: ptr::null()
22392 },
22393 JSFunctionSpec {
22394 name: JSPropertySpec_Name { string_: c"getRenderbufferParameter".as_ptr() },
22395 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getRenderbufferParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
22396 nargs: 2,
22397 flags: (JSPROP_ENUMERATE) as u16,
22398 selfHostedName: ptr::null()
22399 },
22400 JSFunctionSpec {
22401 name: JSPropertySpec_Name { string_: c"getShaderParameter".as_ptr() },
22402 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getShaderParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
22403 nargs: 2,
22404 flags: (JSPROP_ENUMERATE) as u16,
22405 selfHostedName: ptr::null()
22406 },
22407 JSFunctionSpec {
22408 name: JSPropertySpec_Name { string_: c"getShaderPrecisionFormat".as_ptr() },
22409 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getShaderPrecisionFormat_methodinfo.get() } as *const _ as *const JSJitInfo },
22410 nargs: 2,
22411 flags: (JSPROP_ENUMERATE) as u16,
22412 selfHostedName: ptr::null()
22413 },
22414 JSFunctionSpec {
22415 name: JSPropertySpec_Name { string_: c"getShaderInfoLog".as_ptr() },
22416 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getShaderInfoLog_methodinfo.get() } as *const _ as *const JSJitInfo },
22417 nargs: 1,
22418 flags: (JSPROP_ENUMERATE) as u16,
22419 selfHostedName: ptr::null()
22420 },
22421 JSFunctionSpec {
22422 name: JSPropertySpec_Name { string_: c"getShaderSource".as_ptr() },
22423 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getShaderSource_methodinfo.get() } as *const _ as *const JSJitInfo },
22424 nargs: 1,
22425 flags: (JSPROP_ENUMERATE) as u16,
22426 selfHostedName: ptr::null()
22427 },
22428 JSFunctionSpec {
22429 name: JSPropertySpec_Name { string_: c"getTexParameter".as_ptr() },
22430 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getTexParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
22431 nargs: 2,
22432 flags: (JSPROP_ENUMERATE) as u16,
22433 selfHostedName: ptr::null()
22434 },
22435 JSFunctionSpec {
22436 name: JSPropertySpec_Name { string_: c"getUniform".as_ptr() },
22437 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getUniform_methodinfo.get() } as *const _ as *const JSJitInfo },
22438 nargs: 2,
22439 flags: (JSPROP_ENUMERATE) as u16,
22440 selfHostedName: ptr::null()
22441 },
22442 JSFunctionSpec {
22443 name: JSPropertySpec_Name { string_: c"getUniformLocation".as_ptr() },
22444 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getUniformLocation_methodinfo.get() } as *const _ as *const JSJitInfo },
22445 nargs: 2,
22446 flags: (JSPROP_ENUMERATE) as u16,
22447 selfHostedName: ptr::null()
22448 },
22449 JSFunctionSpec {
22450 name: JSPropertySpec_Name { string_: c"getVertexAttrib".as_ptr() },
22451 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getVertexAttrib_methodinfo.get() } as *const _ as *const JSJitInfo },
22452 nargs: 2,
22453 flags: (JSPROP_ENUMERATE) as u16,
22454 selfHostedName: ptr::null()
22455 },
22456 JSFunctionSpec {
22457 name: JSPropertySpec_Name { string_: c"getVertexAttribOffset".as_ptr() },
22458 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getVertexAttribOffset_methodinfo.get() } as *const _ as *const JSJitInfo },
22459 nargs: 2,
22460 flags: (JSPROP_ENUMERATE) as u16,
22461 selfHostedName: ptr::null()
22462 },
22463 JSFunctionSpec {
22464 name: JSPropertySpec_Name { string_: c"hint".as_ptr() },
22465 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { hint_methodinfo.get() } as *const _ as *const JSJitInfo },
22466 nargs: 2,
22467 flags: (JSPROP_ENUMERATE) as u16,
22468 selfHostedName: ptr::null()
22469 },
22470 JSFunctionSpec {
22471 name: JSPropertySpec_Name { string_: c"isBuffer".as_ptr() },
22472 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22473 nargs: 1,
22474 flags: (JSPROP_ENUMERATE) as u16,
22475 selfHostedName: ptr::null()
22476 },
22477 JSFunctionSpec {
22478 name: JSPropertySpec_Name { string_: c"isEnabled".as_ptr() },
22479 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isEnabled_methodinfo.get() } as *const _ as *const JSJitInfo },
22480 nargs: 1,
22481 flags: (JSPROP_ENUMERATE) as u16,
22482 selfHostedName: ptr::null()
22483 },
22484 JSFunctionSpec {
22485 name: JSPropertySpec_Name { string_: c"isFramebuffer".as_ptr() },
22486 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22487 nargs: 1,
22488 flags: (JSPROP_ENUMERATE) as u16,
22489 selfHostedName: ptr::null()
22490 },
22491 JSFunctionSpec {
22492 name: JSPropertySpec_Name { string_: c"isProgram".as_ptr() },
22493 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
22494 nargs: 1,
22495 flags: (JSPROP_ENUMERATE) as u16,
22496 selfHostedName: ptr::null()
22497 },
22498 JSFunctionSpec {
22499 name: JSPropertySpec_Name { string_: c"isRenderbuffer".as_ptr() },
22500 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
22501 nargs: 1,
22502 flags: (JSPROP_ENUMERATE) as u16,
22503 selfHostedName: ptr::null()
22504 },
22505 JSFunctionSpec {
22506 name: JSPropertySpec_Name { string_: c"isShader".as_ptr() },
22507 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isShader_methodinfo.get() } as *const _ as *const JSJitInfo },
22508 nargs: 1,
22509 flags: (JSPROP_ENUMERATE) as u16,
22510 selfHostedName: ptr::null()
22511 },
22512 JSFunctionSpec {
22513 name: JSPropertySpec_Name { string_: c"isTexture".as_ptr() },
22514 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
22515 nargs: 1,
22516 flags: (JSPROP_ENUMERATE) as u16,
22517 selfHostedName: ptr::null()
22518 },
22519 JSFunctionSpec {
22520 name: JSPropertySpec_Name { string_: c"lineWidth".as_ptr() },
22521 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { lineWidth_methodinfo.get() } as *const _ as *const JSJitInfo },
22522 nargs: 1,
22523 flags: (JSPROP_ENUMERATE) as u16,
22524 selfHostedName: ptr::null()
22525 },
22526 JSFunctionSpec {
22527 name: JSPropertySpec_Name { string_: c"linkProgram".as_ptr() },
22528 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { linkProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
22529 nargs: 1,
22530 flags: (JSPROP_ENUMERATE) as u16,
22531 selfHostedName: ptr::null()
22532 },
22533 JSFunctionSpec {
22534 name: JSPropertySpec_Name { string_: c"pixelStorei".as_ptr() },
22535 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { pixelStorei_methodinfo.get() } as *const _ as *const JSJitInfo },
22536 nargs: 2,
22537 flags: (JSPROP_ENUMERATE) as u16,
22538 selfHostedName: ptr::null()
22539 },
22540 JSFunctionSpec {
22541 name: JSPropertySpec_Name { string_: c"polygonOffset".as_ptr() },
22542 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { polygonOffset_methodinfo.get() } as *const _ as *const JSJitInfo },
22543 nargs: 2,
22544 flags: (JSPROP_ENUMERATE) as u16,
22545 selfHostedName: ptr::null()
22546 },
22547 JSFunctionSpec {
22548 name: JSPropertySpec_Name { string_: c"renderbufferStorage".as_ptr() },
22549 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { renderbufferStorage_methodinfo.get() } as *const _ as *const JSJitInfo },
22550 nargs: 4,
22551 flags: (JSPROP_ENUMERATE) as u16,
22552 selfHostedName: ptr::null()
22553 },
22554 JSFunctionSpec {
22555 name: JSPropertySpec_Name { string_: c"sampleCoverage".as_ptr() },
22556 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { sampleCoverage_methodinfo.get() } as *const _ as *const JSJitInfo },
22557 nargs: 2,
22558 flags: (JSPROP_ENUMERATE) as u16,
22559 selfHostedName: ptr::null()
22560 },
22561 JSFunctionSpec {
22562 name: JSPropertySpec_Name { string_: c"scissor".as_ptr() },
22563 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { scissor_methodinfo.get() } as *const _ as *const JSJitInfo },
22564 nargs: 4,
22565 flags: (JSPROP_ENUMERATE) as u16,
22566 selfHostedName: ptr::null()
22567 },
22568 JSFunctionSpec {
22569 name: JSPropertySpec_Name { string_: c"shaderSource".as_ptr() },
22570 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { shaderSource_methodinfo.get() } as *const _ as *const JSJitInfo },
22571 nargs: 2,
22572 flags: (JSPROP_ENUMERATE) as u16,
22573 selfHostedName: ptr::null()
22574 },
22575 JSFunctionSpec {
22576 name: JSPropertySpec_Name { string_: c"stencilFunc".as_ptr() },
22577 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilFunc_methodinfo.get() } as *const _ as *const JSJitInfo },
22578 nargs: 3,
22579 flags: (JSPROP_ENUMERATE) as u16,
22580 selfHostedName: ptr::null()
22581 },
22582 JSFunctionSpec {
22583 name: JSPropertySpec_Name { string_: c"stencilFuncSeparate".as_ptr() },
22584 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilFuncSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
22585 nargs: 4,
22586 flags: (JSPROP_ENUMERATE) as u16,
22587 selfHostedName: ptr::null()
22588 },
22589 JSFunctionSpec {
22590 name: JSPropertySpec_Name { string_: c"stencilMask".as_ptr() },
22591 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilMask_methodinfo.get() } as *const _ as *const JSJitInfo },
22592 nargs: 1,
22593 flags: (JSPROP_ENUMERATE) as u16,
22594 selfHostedName: ptr::null()
22595 },
22596 JSFunctionSpec {
22597 name: JSPropertySpec_Name { string_: c"stencilMaskSeparate".as_ptr() },
22598 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilMaskSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
22599 nargs: 2,
22600 flags: (JSPROP_ENUMERATE) as u16,
22601 selfHostedName: ptr::null()
22602 },
22603 JSFunctionSpec {
22604 name: JSPropertySpec_Name { string_: c"stencilOp".as_ptr() },
22605 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilOp_methodinfo.get() } as *const _ as *const JSJitInfo },
22606 nargs: 3,
22607 flags: (JSPROP_ENUMERATE) as u16,
22608 selfHostedName: ptr::null()
22609 },
22610 JSFunctionSpec {
22611 name: JSPropertySpec_Name { string_: c"stencilOpSeparate".as_ptr() },
22612 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilOpSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
22613 nargs: 4,
22614 flags: (JSPROP_ENUMERATE) as u16,
22615 selfHostedName: ptr::null()
22616 },
22617 JSFunctionSpec {
22618 name: JSPropertySpec_Name { string_: c"texParameterf".as_ptr() },
22619 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texParameterf_methodinfo.get() } as *const _ as *const JSJitInfo },
22620 nargs: 3,
22621 flags: (JSPROP_ENUMERATE) as u16,
22622 selfHostedName: ptr::null()
22623 },
22624 JSFunctionSpec {
22625 name: JSPropertySpec_Name { string_: c"texParameteri".as_ptr() },
22626 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texParameteri_methodinfo.get() } as *const _ as *const JSJitInfo },
22627 nargs: 3,
22628 flags: (JSPROP_ENUMERATE) as u16,
22629 selfHostedName: ptr::null()
22630 },
22631 JSFunctionSpec {
22632 name: JSPropertySpec_Name { string_: c"uniform1f".as_ptr() },
22633 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1f_methodinfo.get() } as *const _ as *const JSJitInfo },
22634 nargs: 2,
22635 flags: (JSPROP_ENUMERATE) as u16,
22636 selfHostedName: ptr::null()
22637 },
22638 JSFunctionSpec {
22639 name: JSPropertySpec_Name { string_: c"uniform2f".as_ptr() },
22640 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2f_methodinfo.get() } as *const _ as *const JSJitInfo },
22641 nargs: 3,
22642 flags: (JSPROP_ENUMERATE) as u16,
22643 selfHostedName: ptr::null()
22644 },
22645 JSFunctionSpec {
22646 name: JSPropertySpec_Name { string_: c"uniform3f".as_ptr() },
22647 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3f_methodinfo.get() } as *const _ as *const JSJitInfo },
22648 nargs: 4,
22649 flags: (JSPROP_ENUMERATE) as u16,
22650 selfHostedName: ptr::null()
22651 },
22652 JSFunctionSpec {
22653 name: JSPropertySpec_Name { string_: c"uniform4f".as_ptr() },
22654 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4f_methodinfo.get() } as *const _ as *const JSJitInfo },
22655 nargs: 5,
22656 flags: (JSPROP_ENUMERATE) as u16,
22657 selfHostedName: ptr::null()
22658 },
22659 JSFunctionSpec {
22660 name: JSPropertySpec_Name { string_: c"uniform1i".as_ptr() },
22661 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1i_methodinfo.get() } as *const _ as *const JSJitInfo },
22662 nargs: 2,
22663 flags: (JSPROP_ENUMERATE) as u16,
22664 selfHostedName: ptr::null()
22665 },
22666 JSFunctionSpec {
22667 name: JSPropertySpec_Name { string_: c"uniform2i".as_ptr() },
22668 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2i_methodinfo.get() } as *const _ as *const JSJitInfo },
22669 nargs: 3,
22670 flags: (JSPROP_ENUMERATE) as u16,
22671 selfHostedName: ptr::null()
22672 },
22673 JSFunctionSpec {
22674 name: JSPropertySpec_Name { string_: c"uniform3i".as_ptr() },
22675 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3i_methodinfo.get() } as *const _ as *const JSJitInfo },
22676 nargs: 4,
22677 flags: (JSPROP_ENUMERATE) as u16,
22678 selfHostedName: ptr::null()
22679 },
22680 JSFunctionSpec {
22681 name: JSPropertySpec_Name { string_: c"uniform4i".as_ptr() },
22682 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4i_methodinfo.get() } as *const _ as *const JSJitInfo },
22683 nargs: 5,
22684 flags: (JSPROP_ENUMERATE) as u16,
22685 selfHostedName: ptr::null()
22686 },
22687 JSFunctionSpec {
22688 name: JSPropertySpec_Name { string_: c"useProgram".as_ptr() },
22689 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { useProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
22690 nargs: 1,
22691 flags: (JSPROP_ENUMERATE) as u16,
22692 selfHostedName: ptr::null()
22693 },
22694 JSFunctionSpec {
22695 name: JSPropertySpec_Name { string_: c"validateProgram".as_ptr() },
22696 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { validateProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
22697 nargs: 1,
22698 flags: (JSPROP_ENUMERATE) as u16,
22699 selfHostedName: ptr::null()
22700 },
22701 JSFunctionSpec {
22702 name: JSPropertySpec_Name { string_: c"vertexAttrib1f".as_ptr() },
22703 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib1f_methodinfo.get() } as *const _ as *const JSJitInfo },
22704 nargs: 2,
22705 flags: (JSPROP_ENUMERATE) as u16,
22706 selfHostedName: ptr::null()
22707 },
22708 JSFunctionSpec {
22709 name: JSPropertySpec_Name { string_: c"vertexAttrib2f".as_ptr() },
22710 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib2f_methodinfo.get() } as *const _ as *const JSJitInfo },
22711 nargs: 3,
22712 flags: (JSPROP_ENUMERATE) as u16,
22713 selfHostedName: ptr::null()
22714 },
22715 JSFunctionSpec {
22716 name: JSPropertySpec_Name { string_: c"vertexAttrib3f".as_ptr() },
22717 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib3f_methodinfo.get() } as *const _ as *const JSJitInfo },
22718 nargs: 4,
22719 flags: (JSPROP_ENUMERATE) as u16,
22720 selfHostedName: ptr::null()
22721 },
22722 JSFunctionSpec {
22723 name: JSPropertySpec_Name { string_: c"vertexAttrib4f".as_ptr() },
22724 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib4f_methodinfo.get() } as *const _ as *const JSJitInfo },
22725 nargs: 5,
22726 flags: (JSPROP_ENUMERATE) as u16,
22727 selfHostedName: ptr::null()
22728 },
22729 JSFunctionSpec {
22730 name: JSPropertySpec_Name { string_: c"vertexAttrib1fv".as_ptr() },
22731 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib1fv_methodinfo.get() } as *const _ as *const JSJitInfo },
22732 nargs: 2,
22733 flags: (JSPROP_ENUMERATE) as u16,
22734 selfHostedName: ptr::null()
22735 },
22736 JSFunctionSpec {
22737 name: JSPropertySpec_Name { string_: c"vertexAttrib2fv".as_ptr() },
22738 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib2fv_methodinfo.get() } as *const _ as *const JSJitInfo },
22739 nargs: 2,
22740 flags: (JSPROP_ENUMERATE) as u16,
22741 selfHostedName: ptr::null()
22742 },
22743 JSFunctionSpec {
22744 name: JSPropertySpec_Name { string_: c"vertexAttrib3fv".as_ptr() },
22745 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib3fv_methodinfo.get() } as *const _ as *const JSJitInfo },
22746 nargs: 2,
22747 flags: (JSPROP_ENUMERATE) as u16,
22748 selfHostedName: ptr::null()
22749 },
22750 JSFunctionSpec {
22751 name: JSPropertySpec_Name { string_: c"vertexAttrib4fv".as_ptr() },
22752 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib4fv_methodinfo.get() } as *const _ as *const JSJitInfo },
22753 nargs: 2,
22754 flags: (JSPROP_ENUMERATE) as u16,
22755 selfHostedName: ptr::null()
22756 },
22757 JSFunctionSpec {
22758 name: JSPropertySpec_Name { string_: c"vertexAttribPointer".as_ptr() },
22759 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttribPointer_methodinfo.get() } as *const _ as *const JSJitInfo },
22760 nargs: 6,
22761 flags: (JSPROP_ENUMERATE) as u16,
22762 selfHostedName: ptr::null()
22763 },
22764 JSFunctionSpec {
22765 name: JSPropertySpec_Name { string_: c"viewport".as_ptr() },
22766 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { viewport_methodinfo.get() } as *const _ as *const JSJitInfo },
22767 nargs: 4,
22768 flags: (JSPROP_ENUMERATE) as u16,
22769 selfHostedName: ptr::null()
22770 },
22771 JSFunctionSpec {
22772 name: JSPropertySpec_Name { string_: ptr::null() },
22773 call: JSNativeWrapper { op: None, info: ptr::null() },
22774 nargs: 0,
22775 flags: 0,
22776 selfHostedName: ptr::null()
22777 }]))[..]
22778,
22779&Box::leak(Box::new([
22780 JSFunctionSpec {
22781 name: JSPropertySpec_Name { string_: c"makeXRCompatible".as_ptr() },
22782 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { makeXRCompatible_methodinfo.get() } as *const _ as *const JSJitInfo },
22783 nargs: 0,
22784 flags: (JSPROP_ENUMERATE) as u16,
22785 selfHostedName: ptr::null()
22786 },
22787 JSFunctionSpec {
22788 name: JSPropertySpec_Name { string_: ptr::null() },
22789 call: JSNativeWrapper { op: None, info: ptr::null() },
22790 nargs: 0,
22791 flags: 0,
22792 selfHostedName: ptr::null()
22793 }]))[..]
22794])));
22795}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
22796
22797pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
22798 sMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[0]),
22799 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[1]),
22800 Guard::new(&[Condition::Pref("dom_webxr_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[2])])));
22801}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
22802
22803pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
22804 sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
22805 JSPropertySpec {
22806 name: JSPropertySpec_Name { string_: c"canvas".as_ptr() },
22807 attributes_: (JSPROP_ENUMERATE),
22808 kind_: (JSPropertySpec_Kind::NativeAccessor),
22809 u: JSPropertySpec_AccessorsOrValue {
22810 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
22811 getter: JSPropertySpec_Accessor {
22812 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { canvas_getterinfo.get() } },
22813 },
22814 setter: JSPropertySpec_Accessor {
22815 native: JSNativeWrapper { op: None, info: ptr::null() },
22816 }
22817 }
22818 }
22819 }
22820,
22821 JSPropertySpec {
22822 name: JSPropertySpec_Name { string_: c"drawingBufferWidth".as_ptr() },
22823 attributes_: (JSPROP_ENUMERATE),
22824 kind_: (JSPropertySpec_Kind::NativeAccessor),
22825 u: JSPropertySpec_AccessorsOrValue {
22826 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
22827 getter: JSPropertySpec_Accessor {
22828 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { drawingBufferWidth_getterinfo.get() } },
22829 },
22830 setter: JSPropertySpec_Accessor {
22831 native: JSNativeWrapper { op: None, info: ptr::null() },
22832 }
22833 }
22834 }
22835 }
22836,
22837 JSPropertySpec {
22838 name: JSPropertySpec_Name { string_: c"drawingBufferHeight".as_ptr() },
22839 attributes_: (JSPROP_ENUMERATE),
22840 kind_: (JSPropertySpec_Kind::NativeAccessor),
22841 u: JSPropertySpec_AccessorsOrValue {
22842 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
22843 getter: JSPropertySpec_Accessor {
22844 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { drawingBufferHeight_getterinfo.get() } },
22845 },
22846 setter: JSPropertySpec_Accessor {
22847 native: JSNativeWrapper { op: None, info: ptr::null() },
22848 }
22849 }
22850 }
22851 }
22852,
22853 JSPropertySpec::ZERO]))[..]
22854,
22855&Box::leak(Box::new([
22856 JSPropertySpec {
22857 name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
22858 attributes_: (JSPROP_READONLY),
22859 kind_: (JSPropertySpec_Kind::Value),
22860 u: JSPropertySpec_AccessorsOrValue {
22861 value: JSPropertySpec_ValueWrapper {
22862 type_: JSPropertySpec_ValueWrapper_Type::String,
22863 __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
22864 string: c"WebGL2RenderingContext".as_ptr(),
22865 }
22866 }
22867 }
22868 }
22869,
22870 JSPropertySpec::ZERO]))[..]
22871])));
22872}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
22873
22874pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
22875 sAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
22876 Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
22877}static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();
22878
22879pub(crate) fn init_sConstants_specs<D: DomTypes>() {
22880 sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
22881 ConstantSpec { name: c"READ_BUFFER", value: ConstantVal::Uint(3074) },
22882 ConstantSpec { name: c"UNPACK_ROW_LENGTH", value: ConstantVal::Uint(3314) },
22883 ConstantSpec { name: c"UNPACK_SKIP_ROWS", value: ConstantVal::Uint(3315) },
22884 ConstantSpec { name: c"UNPACK_SKIP_PIXELS", value: ConstantVal::Uint(3316) },
22885 ConstantSpec { name: c"PACK_ROW_LENGTH", value: ConstantVal::Uint(3330) },
22886 ConstantSpec { name: c"PACK_SKIP_ROWS", value: ConstantVal::Uint(3331) },
22887 ConstantSpec { name: c"PACK_SKIP_PIXELS", value: ConstantVal::Uint(3332) },
22888 ConstantSpec { name: c"COLOR", value: ConstantVal::Uint(6144) },
22889 ConstantSpec { name: c"DEPTH", value: ConstantVal::Uint(6145) },
22890 ConstantSpec { name: c"STENCIL", value: ConstantVal::Uint(6146) },
22891 ConstantSpec { name: c"RED", value: ConstantVal::Uint(6403) },
22892 ConstantSpec { name: c"RGB8", value: ConstantVal::Uint(32849) },
22893 ConstantSpec { name: c"RGBA8", value: ConstantVal::Uint(32856) },
22894 ConstantSpec { name: c"RGB10_A2", value: ConstantVal::Uint(32857) },
22895 ConstantSpec { name: c"TEXTURE_BINDING_3D", value: ConstantVal::Uint(32874) },
22896 ConstantSpec { name: c"UNPACK_SKIP_IMAGES", value: ConstantVal::Uint(32877) },
22897 ConstantSpec { name: c"UNPACK_IMAGE_HEIGHT", value: ConstantVal::Uint(32878) },
22898 ConstantSpec { name: c"TEXTURE_3D", value: ConstantVal::Uint(32879) },
22899 ConstantSpec { name: c"TEXTURE_WRAP_R", value: ConstantVal::Uint(32882) },
22900 ConstantSpec { name: c"MAX_3D_TEXTURE_SIZE", value: ConstantVal::Uint(32883) },
22901 ConstantSpec { name: c"UNSIGNED_INT_2_10_10_10_REV", value: ConstantVal::Uint(33640) },
22902 ConstantSpec { name: c"MAX_ELEMENTS_VERTICES", value: ConstantVal::Uint(33000) },
22903 ConstantSpec { name: c"MAX_ELEMENTS_INDICES", value: ConstantVal::Uint(33001) },
22904 ConstantSpec { name: c"TEXTURE_MIN_LOD", value: ConstantVal::Uint(33082) },
22905 ConstantSpec { name: c"TEXTURE_MAX_LOD", value: ConstantVal::Uint(33083) },
22906 ConstantSpec { name: c"TEXTURE_BASE_LEVEL", value: ConstantVal::Uint(33084) },
22907 ConstantSpec { name: c"TEXTURE_MAX_LEVEL", value: ConstantVal::Uint(33085) },
22908 ConstantSpec { name: c"MIN", value: ConstantVal::Uint(32775) },
22909 ConstantSpec { name: c"MAX", value: ConstantVal::Uint(32776) },
22910 ConstantSpec { name: c"DEPTH_COMPONENT24", value: ConstantVal::Uint(33190) },
22911 ConstantSpec { name: c"MAX_TEXTURE_LOD_BIAS", value: ConstantVal::Uint(34045) },
22912 ConstantSpec { name: c"TEXTURE_COMPARE_MODE", value: ConstantVal::Uint(34892) },
22913 ConstantSpec { name: c"TEXTURE_COMPARE_FUNC", value: ConstantVal::Uint(34893) },
22914 ConstantSpec { name: c"CURRENT_QUERY", value: ConstantVal::Uint(34917) },
22915 ConstantSpec { name: c"QUERY_RESULT", value: ConstantVal::Uint(34918) },
22916 ConstantSpec { name: c"QUERY_RESULT_AVAILABLE", value: ConstantVal::Uint(34919) },
22917 ConstantSpec { name: c"STREAM_READ", value: ConstantVal::Uint(35041) },
22918 ConstantSpec { name: c"STREAM_COPY", value: ConstantVal::Uint(35042) },
22919 ConstantSpec { name: c"STATIC_READ", value: ConstantVal::Uint(35045) },
22920 ConstantSpec { name: c"STATIC_COPY", value: ConstantVal::Uint(35046) },
22921 ConstantSpec { name: c"DYNAMIC_READ", value: ConstantVal::Uint(35049) },
22922 ConstantSpec { name: c"DYNAMIC_COPY", value: ConstantVal::Uint(35050) },
22923 ConstantSpec { name: c"MAX_DRAW_BUFFERS", value: ConstantVal::Uint(34852) },
22924 ConstantSpec { name: c"DRAW_BUFFER0", value: ConstantVal::Uint(34853) },
22925 ConstantSpec { name: c"DRAW_BUFFER1", value: ConstantVal::Uint(34854) },
22926 ConstantSpec { name: c"DRAW_BUFFER2", value: ConstantVal::Uint(34855) },
22927 ConstantSpec { name: c"DRAW_BUFFER3", value: ConstantVal::Uint(34856) },
22928 ConstantSpec { name: c"DRAW_BUFFER4", value: ConstantVal::Uint(34857) },
22929 ConstantSpec { name: c"DRAW_BUFFER5", value: ConstantVal::Uint(34858) },
22930 ConstantSpec { name: c"DRAW_BUFFER6", value: ConstantVal::Uint(34859) },
22931 ConstantSpec { name: c"DRAW_BUFFER7", value: ConstantVal::Uint(34860) },
22932 ConstantSpec { name: c"DRAW_BUFFER8", value: ConstantVal::Uint(34861) },
22933 ConstantSpec { name: c"DRAW_BUFFER9", value: ConstantVal::Uint(34862) },
22934 ConstantSpec { name: c"DRAW_BUFFER10", value: ConstantVal::Uint(34863) },
22935 ConstantSpec { name: c"DRAW_BUFFER11", value: ConstantVal::Uint(34864) },
22936 ConstantSpec { name: c"DRAW_BUFFER12", value: ConstantVal::Uint(34865) },
22937 ConstantSpec { name: c"DRAW_BUFFER13", value: ConstantVal::Uint(34866) },
22938 ConstantSpec { name: c"DRAW_BUFFER14", value: ConstantVal::Uint(34867) },
22939 ConstantSpec { name: c"DRAW_BUFFER15", value: ConstantVal::Uint(34868) },
22940 ConstantSpec { name: c"MAX_FRAGMENT_UNIFORM_COMPONENTS", value: ConstantVal::Uint(35657) },
22941 ConstantSpec { name: c"MAX_VERTEX_UNIFORM_COMPONENTS", value: ConstantVal::Uint(35658) },
22942 ConstantSpec { name: c"SAMPLER_3D", value: ConstantVal::Uint(35679) },
22943 ConstantSpec { name: c"SAMPLER_2D_SHADOW", value: ConstantVal::Uint(35682) },
22944 ConstantSpec { name: c"FRAGMENT_SHADER_DERIVATIVE_HINT", value: ConstantVal::Uint(35723) },
22945 ConstantSpec { name: c"PIXEL_PACK_BUFFER", value: ConstantVal::Uint(35051) },
22946 ConstantSpec { name: c"PIXEL_UNPACK_BUFFER", value: ConstantVal::Uint(35052) },
22947 ConstantSpec { name: c"PIXEL_PACK_BUFFER_BINDING", value: ConstantVal::Uint(35053) },
22948 ConstantSpec { name: c"PIXEL_UNPACK_BUFFER_BINDING", value: ConstantVal::Uint(35055) },
22949 ConstantSpec { name: c"FLOAT_MAT2x3", value: ConstantVal::Uint(35685) },
22950 ConstantSpec { name: c"FLOAT_MAT2x4", value: ConstantVal::Uint(35686) },
22951 ConstantSpec { name: c"FLOAT_MAT3x2", value: ConstantVal::Uint(35687) },
22952 ConstantSpec { name: c"FLOAT_MAT3x4", value: ConstantVal::Uint(35688) },
22953 ConstantSpec { name: c"FLOAT_MAT4x2", value: ConstantVal::Uint(35689) },
22954 ConstantSpec { name: c"FLOAT_MAT4x3", value: ConstantVal::Uint(35690) },
22955 ConstantSpec { name: c"SRGB", value: ConstantVal::Uint(35904) },
22956 ConstantSpec { name: c"SRGB8", value: ConstantVal::Uint(35905) },
22957 ConstantSpec { name: c"SRGB8_ALPHA8", value: ConstantVal::Uint(35907) },
22958 ConstantSpec { name: c"COMPARE_REF_TO_TEXTURE", value: ConstantVal::Uint(34894) },
22959 ConstantSpec { name: c"RGBA32F", value: ConstantVal::Uint(34836) },
22960 ConstantSpec { name: c"RGB32F", value: ConstantVal::Uint(34837) },
22961 ConstantSpec { name: c"RGBA16F", value: ConstantVal::Uint(34842) },
22962 ConstantSpec { name: c"RGB16F", value: ConstantVal::Uint(34843) },
22963 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_INTEGER", value: ConstantVal::Uint(35069) },
22964 ConstantSpec { name: c"MAX_ARRAY_TEXTURE_LAYERS", value: ConstantVal::Uint(35071) },
22965 ConstantSpec { name: c"MIN_PROGRAM_TEXEL_OFFSET", value: ConstantVal::Uint(35076) },
22966 ConstantSpec { name: c"MAX_PROGRAM_TEXEL_OFFSET", value: ConstantVal::Uint(35077) },
22967 ConstantSpec { name: c"MAX_VARYING_COMPONENTS", value: ConstantVal::Uint(35659) },
22968 ConstantSpec { name: c"TEXTURE_2D_ARRAY", value: ConstantVal::Uint(35866) },
22969 ConstantSpec { name: c"TEXTURE_BINDING_2D_ARRAY", value: ConstantVal::Uint(35869) },
22970 ConstantSpec { name: c"R11F_G11F_B10F", value: ConstantVal::Uint(35898) },
22971 ConstantSpec { name: c"UNSIGNED_INT_10F_11F_11F_REV", value: ConstantVal::Uint(35899) },
22972 ConstantSpec { name: c"RGB9_E5", value: ConstantVal::Uint(35901) },
22973 ConstantSpec { name: c"UNSIGNED_INT_5_9_9_9_REV", value: ConstantVal::Uint(35902) },
22974 ConstantSpec { name: c"TRANSFORM_FEEDBACK_BUFFER_MODE", value: ConstantVal::Uint(35967) },
22975 ConstantSpec { name: c"MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", value: ConstantVal::Uint(35968) },
22976 ConstantSpec { name: c"TRANSFORM_FEEDBACK_VARYINGS", value: ConstantVal::Uint(35971) },
22977 ConstantSpec { name: c"TRANSFORM_FEEDBACK_BUFFER_START", value: ConstantVal::Uint(35972) },
22978 ConstantSpec { name: c"TRANSFORM_FEEDBACK_BUFFER_SIZE", value: ConstantVal::Uint(35973) },
22979 ConstantSpec { name: c"TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN", value: ConstantVal::Uint(35976) },
22980 ConstantSpec { name: c"RASTERIZER_DISCARD", value: ConstantVal::Uint(35977) },
22981 ConstantSpec { name: c"MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", value: ConstantVal::Uint(35978) },
22982 ConstantSpec { name: c"MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", value: ConstantVal::Uint(35979) },
22983 ConstantSpec { name: c"INTERLEAVED_ATTRIBS", value: ConstantVal::Uint(35980) },
22984 ConstantSpec { name: c"SEPARATE_ATTRIBS", value: ConstantVal::Uint(35981) },
22985 ConstantSpec { name: c"TRANSFORM_FEEDBACK_BUFFER", value: ConstantVal::Uint(35982) },
22986 ConstantSpec { name: c"TRANSFORM_FEEDBACK_BUFFER_BINDING", value: ConstantVal::Uint(35983) },
22987 ConstantSpec { name: c"RGBA32UI", value: ConstantVal::Uint(36208) },
22988 ConstantSpec { name: c"RGB32UI", value: ConstantVal::Uint(36209) },
22989 ConstantSpec { name: c"RGBA16UI", value: ConstantVal::Uint(36214) },
22990 ConstantSpec { name: c"RGB16UI", value: ConstantVal::Uint(36215) },
22991 ConstantSpec { name: c"RGBA8UI", value: ConstantVal::Uint(36220) },
22992 ConstantSpec { name: c"RGB8UI", value: ConstantVal::Uint(36221) },
22993 ConstantSpec { name: c"RGBA32I", value: ConstantVal::Uint(36226) },
22994 ConstantSpec { name: c"RGB32I", value: ConstantVal::Uint(36227) },
22995 ConstantSpec { name: c"RGBA16I", value: ConstantVal::Uint(36232) },
22996 ConstantSpec { name: c"RGB16I", value: ConstantVal::Uint(36233) },
22997 ConstantSpec { name: c"RGBA8I", value: ConstantVal::Uint(36238) },
22998 ConstantSpec { name: c"RGB8I", value: ConstantVal::Uint(36239) },
22999 ConstantSpec { name: c"RED_INTEGER", value: ConstantVal::Uint(36244) },
23000 ConstantSpec { name: c"RGB_INTEGER", value: ConstantVal::Uint(36248) },
23001 ConstantSpec { name: c"RGBA_INTEGER", value: ConstantVal::Uint(36249) },
23002 ConstantSpec { name: c"SAMPLER_2D_ARRAY", value: ConstantVal::Uint(36289) },
23003 ConstantSpec { name: c"SAMPLER_2D_ARRAY_SHADOW", value: ConstantVal::Uint(36292) },
23004 ConstantSpec { name: c"SAMPLER_CUBE_SHADOW", value: ConstantVal::Uint(36293) },
23005 ConstantSpec { name: c"UNSIGNED_INT_VEC2", value: ConstantVal::Uint(36294) },
23006 ConstantSpec { name: c"UNSIGNED_INT_VEC3", value: ConstantVal::Uint(36295) },
23007 ConstantSpec { name: c"UNSIGNED_INT_VEC4", value: ConstantVal::Uint(36296) },
23008 ConstantSpec { name: c"INT_SAMPLER_2D", value: ConstantVal::Uint(36298) },
23009 ConstantSpec { name: c"INT_SAMPLER_3D", value: ConstantVal::Uint(36299) },
23010 ConstantSpec { name: c"INT_SAMPLER_CUBE", value: ConstantVal::Uint(36300) },
23011 ConstantSpec { name: c"INT_SAMPLER_2D_ARRAY", value: ConstantVal::Uint(36303) },
23012 ConstantSpec { name: c"UNSIGNED_INT_SAMPLER_2D", value: ConstantVal::Uint(36306) },
23013 ConstantSpec { name: c"UNSIGNED_INT_SAMPLER_3D", value: ConstantVal::Uint(36307) },
23014 ConstantSpec { name: c"UNSIGNED_INT_SAMPLER_CUBE", value: ConstantVal::Uint(36308) },
23015 ConstantSpec { name: c"UNSIGNED_INT_SAMPLER_2D_ARRAY", value: ConstantVal::Uint(36311) },
23016 ConstantSpec { name: c"DEPTH_COMPONENT32F", value: ConstantVal::Uint(36012) },
23017 ConstantSpec { name: c"DEPTH32F_STENCIL8", value: ConstantVal::Uint(36013) },
23018 ConstantSpec { name: c"FLOAT_32_UNSIGNED_INT_24_8_REV", value: ConstantVal::Uint(36269) },
23019 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING", value: ConstantVal::Uint(33296) },
23020 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE", value: ConstantVal::Uint(33297) },
23021 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_RED_SIZE", value: ConstantVal::Uint(33298) },
23022 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_GREEN_SIZE", value: ConstantVal::Uint(33299) },
23023 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_BLUE_SIZE", value: ConstantVal::Uint(33300) },
23024 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE", value: ConstantVal::Uint(33301) },
23025 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE", value: ConstantVal::Uint(33302) },
23026 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE", value: ConstantVal::Uint(33303) },
23027 ConstantSpec { name: c"FRAMEBUFFER_DEFAULT", value: ConstantVal::Uint(33304) },
23028 ConstantSpec { name: c"UNSIGNED_INT_24_8", value: ConstantVal::Uint(34042) },
23029 ConstantSpec { name: c"DEPTH24_STENCIL8", value: ConstantVal::Uint(35056) },
23030 ConstantSpec { name: c"UNSIGNED_NORMALIZED", value: ConstantVal::Uint(35863) },
23031 ConstantSpec { name: c"DRAW_FRAMEBUFFER_BINDING", value: ConstantVal::Uint(36006) },
23032 ConstantSpec { name: c"READ_FRAMEBUFFER", value: ConstantVal::Uint(36008) },
23033 ConstantSpec { name: c"DRAW_FRAMEBUFFER", value: ConstantVal::Uint(36009) },
23034 ConstantSpec { name: c"READ_FRAMEBUFFER_BINDING", value: ConstantVal::Uint(36010) },
23035 ConstantSpec { name: c"RENDERBUFFER_SAMPLES", value: ConstantVal::Uint(36011) },
23036 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER", value: ConstantVal::Uint(36052) },
23037 ConstantSpec { name: c"MAX_COLOR_ATTACHMENTS", value: ConstantVal::Uint(36063) },
23038 ConstantSpec { name: c"COLOR_ATTACHMENT1", value: ConstantVal::Uint(36065) },
23039 ConstantSpec { name: c"COLOR_ATTACHMENT2", value: ConstantVal::Uint(36066) },
23040 ConstantSpec { name: c"COLOR_ATTACHMENT3", value: ConstantVal::Uint(36067) },
23041 ConstantSpec { name: c"COLOR_ATTACHMENT4", value: ConstantVal::Uint(36068) },
23042 ConstantSpec { name: c"COLOR_ATTACHMENT5", value: ConstantVal::Uint(36069) },
23043 ConstantSpec { name: c"COLOR_ATTACHMENT6", value: ConstantVal::Uint(36070) },
23044 ConstantSpec { name: c"COLOR_ATTACHMENT7", value: ConstantVal::Uint(36071) },
23045 ConstantSpec { name: c"COLOR_ATTACHMENT8", value: ConstantVal::Uint(36072) },
23046 ConstantSpec { name: c"COLOR_ATTACHMENT9", value: ConstantVal::Uint(36073) },
23047 ConstantSpec { name: c"COLOR_ATTACHMENT10", value: ConstantVal::Uint(36074) },
23048 ConstantSpec { name: c"COLOR_ATTACHMENT11", value: ConstantVal::Uint(36075) },
23049 ConstantSpec { name: c"COLOR_ATTACHMENT12", value: ConstantVal::Uint(36076) },
23050 ConstantSpec { name: c"COLOR_ATTACHMENT13", value: ConstantVal::Uint(36077) },
23051 ConstantSpec { name: c"COLOR_ATTACHMENT14", value: ConstantVal::Uint(36078) },
23052 ConstantSpec { name: c"COLOR_ATTACHMENT15", value: ConstantVal::Uint(36079) },
23053 ConstantSpec { name: c"FRAMEBUFFER_INCOMPLETE_MULTISAMPLE", value: ConstantVal::Uint(36182) },
23054 ConstantSpec { name: c"MAX_SAMPLES", value: ConstantVal::Uint(36183) },
23055 ConstantSpec { name: c"HALF_FLOAT", value: ConstantVal::Uint(5131) },
23056 ConstantSpec { name: c"RG", value: ConstantVal::Uint(33319) },
23057 ConstantSpec { name: c"RG_INTEGER", value: ConstantVal::Uint(33320) },
23058 ConstantSpec { name: c"R8", value: ConstantVal::Uint(33321) },
23059 ConstantSpec { name: c"RG8", value: ConstantVal::Uint(33323) },
23060 ConstantSpec { name: c"R16F", value: ConstantVal::Uint(33325) },
23061 ConstantSpec { name: c"R32F", value: ConstantVal::Uint(33326) },
23062 ConstantSpec { name: c"RG16F", value: ConstantVal::Uint(33327) },
23063 ConstantSpec { name: c"RG32F", value: ConstantVal::Uint(33328) },
23064 ConstantSpec { name: c"R8I", value: ConstantVal::Uint(33329) },
23065 ConstantSpec { name: c"R8UI", value: ConstantVal::Uint(33330) },
23066 ConstantSpec { name: c"R16I", value: ConstantVal::Uint(33331) },
23067 ConstantSpec { name: c"R16UI", value: ConstantVal::Uint(33332) },
23068 ConstantSpec { name: c"R32I", value: ConstantVal::Uint(33333) },
23069 ConstantSpec { name: c"R32UI", value: ConstantVal::Uint(33334) },
23070 ConstantSpec { name: c"RG8I", value: ConstantVal::Uint(33335) },
23071 ConstantSpec { name: c"RG8UI", value: ConstantVal::Uint(33336) },
23072 ConstantSpec { name: c"RG16I", value: ConstantVal::Uint(33337) },
23073 ConstantSpec { name: c"RG16UI", value: ConstantVal::Uint(33338) },
23074 ConstantSpec { name: c"RG32I", value: ConstantVal::Uint(33339) },
23075 ConstantSpec { name: c"RG32UI", value: ConstantVal::Uint(33340) },
23076 ConstantSpec { name: c"VERTEX_ARRAY_BINDING", value: ConstantVal::Uint(34229) },
23077 ConstantSpec { name: c"R8_SNORM", value: ConstantVal::Uint(36756) },
23078 ConstantSpec { name: c"RG8_SNORM", value: ConstantVal::Uint(36757) },
23079 ConstantSpec { name: c"RGB8_SNORM", value: ConstantVal::Uint(36758) },
23080 ConstantSpec { name: c"RGBA8_SNORM", value: ConstantVal::Uint(36759) },
23081 ConstantSpec { name: c"SIGNED_NORMALIZED", value: ConstantVal::Uint(36764) },
23082 ConstantSpec { name: c"COPY_READ_BUFFER", value: ConstantVal::Uint(36662) },
23083 ConstantSpec { name: c"COPY_WRITE_BUFFER", value: ConstantVal::Uint(36663) },
23084 ConstantSpec { name: c"COPY_READ_BUFFER_BINDING", value: ConstantVal::Uint(36662) },
23085 ConstantSpec { name: c"COPY_WRITE_BUFFER_BINDING", value: ConstantVal::Uint(36663) },
23086 ConstantSpec { name: c"UNIFORM_BUFFER", value: ConstantVal::Uint(35345) },
23087 ConstantSpec { name: c"UNIFORM_BUFFER_BINDING", value: ConstantVal::Uint(35368) },
23088 ConstantSpec { name: c"UNIFORM_BUFFER_START", value: ConstantVal::Uint(35369) },
23089 ConstantSpec { name: c"UNIFORM_BUFFER_SIZE", value: ConstantVal::Uint(35370) },
23090 ConstantSpec { name: c"MAX_VERTEX_UNIFORM_BLOCKS", value: ConstantVal::Uint(35371) },
23091 ConstantSpec { name: c"MAX_FRAGMENT_UNIFORM_BLOCKS", value: ConstantVal::Uint(35373) },
23092 ConstantSpec { name: c"MAX_COMBINED_UNIFORM_BLOCKS", value: ConstantVal::Uint(35374) },
23093 ConstantSpec { name: c"MAX_UNIFORM_BUFFER_BINDINGS", value: ConstantVal::Uint(35375) },
23094 ConstantSpec { name: c"MAX_UNIFORM_BLOCK_SIZE", value: ConstantVal::Uint(35376) },
23095 ConstantSpec { name: c"MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", value: ConstantVal::Uint(35377) },
23096 ConstantSpec { name: c"MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", value: ConstantVal::Uint(35379) },
23097 ConstantSpec { name: c"UNIFORM_BUFFER_OFFSET_ALIGNMENT", value: ConstantVal::Uint(35380) },
23098 ConstantSpec { name: c"ACTIVE_UNIFORM_BLOCKS", value: ConstantVal::Uint(35382) },
23099 ConstantSpec { name: c"UNIFORM_TYPE", value: ConstantVal::Uint(35383) },
23100 ConstantSpec { name: c"UNIFORM_SIZE", value: ConstantVal::Uint(35384) },
23101 ConstantSpec { name: c"UNIFORM_BLOCK_INDEX", value: ConstantVal::Uint(35386) },
23102 ConstantSpec { name: c"UNIFORM_OFFSET", value: ConstantVal::Uint(35387) },
23103 ConstantSpec { name: c"UNIFORM_ARRAY_STRIDE", value: ConstantVal::Uint(35388) },
23104 ConstantSpec { name: c"UNIFORM_MATRIX_STRIDE", value: ConstantVal::Uint(35389) },
23105 ConstantSpec { name: c"UNIFORM_IS_ROW_MAJOR", value: ConstantVal::Uint(35390) },
23106 ConstantSpec { name: c"UNIFORM_BLOCK_BINDING", value: ConstantVal::Uint(35391) },
23107 ConstantSpec { name: c"UNIFORM_BLOCK_DATA_SIZE", value: ConstantVal::Uint(35392) },
23108 ConstantSpec { name: c"UNIFORM_BLOCK_ACTIVE_UNIFORMS", value: ConstantVal::Uint(35394) },
23109 ConstantSpec { name: c"UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", value: ConstantVal::Uint(35395) },
23110 ConstantSpec { name: c"UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER", value: ConstantVal::Uint(35396) },
23111 ConstantSpec { name: c"UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER", value: ConstantVal::Uint(35398) },
23112 ConstantSpec { name: c"INVALID_INDEX", value: ConstantVal::Uint(4294967295) },
23113 ConstantSpec { name: c"MAX_VERTEX_OUTPUT_COMPONENTS", value: ConstantVal::Uint(37154) },
23114 ConstantSpec { name: c"MAX_FRAGMENT_INPUT_COMPONENTS", value: ConstantVal::Uint(37157) },
23115 ConstantSpec { name: c"MAX_SERVER_WAIT_TIMEOUT", value: ConstantVal::Uint(37137) },
23116 ConstantSpec { name: c"OBJECT_TYPE", value: ConstantVal::Uint(37138) },
23117 ConstantSpec { name: c"SYNC_CONDITION", value: ConstantVal::Uint(37139) },
23118 ConstantSpec { name: c"SYNC_STATUS", value: ConstantVal::Uint(37140) },
23119 ConstantSpec { name: c"SYNC_FLAGS", value: ConstantVal::Uint(37141) },
23120 ConstantSpec { name: c"SYNC_FENCE", value: ConstantVal::Uint(37142) },
23121 ConstantSpec { name: c"SYNC_GPU_COMMANDS_COMPLETE", value: ConstantVal::Uint(37143) },
23122 ConstantSpec { name: c"UNSIGNALED", value: ConstantVal::Uint(37144) },
23123 ConstantSpec { name: c"SIGNALED", value: ConstantVal::Uint(37145) },
23124 ConstantSpec { name: c"ALREADY_SIGNALED", value: ConstantVal::Uint(37146) },
23125 ConstantSpec { name: c"TIMEOUT_EXPIRED", value: ConstantVal::Uint(37147) },
23126 ConstantSpec { name: c"CONDITION_SATISFIED", value: ConstantVal::Uint(37148) },
23127 ConstantSpec { name: c"WAIT_FAILED", value: ConstantVal::Uint(37149) },
23128 ConstantSpec { name: c"SYNC_FLUSH_COMMANDS_BIT", value: ConstantVal::Uint(1) },
23129 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_DIVISOR", value: ConstantVal::Uint(35070) },
23130 ConstantSpec { name: c"ANY_SAMPLES_PASSED", value: ConstantVal::Uint(35887) },
23131 ConstantSpec { name: c"ANY_SAMPLES_PASSED_CONSERVATIVE", value: ConstantVal::Uint(36202) },
23132 ConstantSpec { name: c"SAMPLER_BINDING", value: ConstantVal::Uint(35097) },
23133 ConstantSpec { name: c"RGB10_A2UI", value: ConstantVal::Uint(36975) },
23134 ConstantSpec { name: c"INT_2_10_10_10_REV", value: ConstantVal::Uint(36255) },
23135 ConstantSpec { name: c"TRANSFORM_FEEDBACK", value: ConstantVal::Uint(36386) },
23136 ConstantSpec { name: c"TRANSFORM_FEEDBACK_PAUSED", value: ConstantVal::Uint(36387) },
23137 ConstantSpec { name: c"TRANSFORM_FEEDBACK_ACTIVE", value: ConstantVal::Uint(36388) },
23138 ConstantSpec { name: c"TRANSFORM_FEEDBACK_BINDING", value: ConstantVal::Uint(36389) },
23139 ConstantSpec { name: c"TEXTURE_IMMUTABLE_FORMAT", value: ConstantVal::Uint(37167) },
23140 ConstantSpec { name: c"MAX_ELEMENT_INDEX", value: ConstantVal::Uint(36203) },
23141 ConstantSpec { name: c"TEXTURE_IMMUTABLE_LEVELS", value: ConstantVal::Uint(33503) },
23142 ConstantSpec { name: c"TIMEOUT_IGNORED", value: ConstantVal::Double(-1 as f64) },
23143 ConstantSpec { name: c"MAX_CLIENT_WAIT_TIMEOUT_WEBGL", value: ConstantVal::Uint(37447) }]))[..]
23144,
23145&Box::leak(Box::new([
23146 ConstantSpec { name: c"DEPTH_BUFFER_BIT", value: ConstantVal::Uint(256) },
23147 ConstantSpec { name: c"STENCIL_BUFFER_BIT", value: ConstantVal::Uint(1024) },
23148 ConstantSpec { name: c"COLOR_BUFFER_BIT", value: ConstantVal::Uint(16384) },
23149 ConstantSpec { name: c"POINTS", value: ConstantVal::Uint(0) },
23150 ConstantSpec { name: c"LINES", value: ConstantVal::Uint(1) },
23151 ConstantSpec { name: c"LINE_LOOP", value: ConstantVal::Uint(2) },
23152 ConstantSpec { name: c"LINE_STRIP", value: ConstantVal::Uint(3) },
23153 ConstantSpec { name: c"TRIANGLES", value: ConstantVal::Uint(4) },
23154 ConstantSpec { name: c"TRIANGLE_STRIP", value: ConstantVal::Uint(5) },
23155 ConstantSpec { name: c"TRIANGLE_FAN", value: ConstantVal::Uint(6) },
23156 ConstantSpec { name: c"ZERO", value: ConstantVal::Uint(0) },
23157 ConstantSpec { name: c"ONE", value: ConstantVal::Uint(1) },
23158 ConstantSpec { name: c"SRC_COLOR", value: ConstantVal::Uint(768) },
23159 ConstantSpec { name: c"ONE_MINUS_SRC_COLOR", value: ConstantVal::Uint(769) },
23160 ConstantSpec { name: c"SRC_ALPHA", value: ConstantVal::Uint(770) },
23161 ConstantSpec { name: c"ONE_MINUS_SRC_ALPHA", value: ConstantVal::Uint(771) },
23162 ConstantSpec { name: c"DST_ALPHA", value: ConstantVal::Uint(772) },
23163 ConstantSpec { name: c"ONE_MINUS_DST_ALPHA", value: ConstantVal::Uint(773) },
23164 ConstantSpec { name: c"DST_COLOR", value: ConstantVal::Uint(774) },
23165 ConstantSpec { name: c"ONE_MINUS_DST_COLOR", value: ConstantVal::Uint(775) },
23166 ConstantSpec { name: c"SRC_ALPHA_SATURATE", value: ConstantVal::Uint(776) },
23167 ConstantSpec { name: c"FUNC_ADD", value: ConstantVal::Uint(32774) },
23168 ConstantSpec { name: c"BLEND_EQUATION", value: ConstantVal::Uint(32777) },
23169 ConstantSpec { name: c"BLEND_EQUATION_RGB", value: ConstantVal::Uint(32777) },
23170 ConstantSpec { name: c"BLEND_EQUATION_ALPHA", value: ConstantVal::Uint(34877) },
23171 ConstantSpec { name: c"FUNC_SUBTRACT", value: ConstantVal::Uint(32778) },
23172 ConstantSpec { name: c"FUNC_REVERSE_SUBTRACT", value: ConstantVal::Uint(32779) },
23173 ConstantSpec { name: c"BLEND_DST_RGB", value: ConstantVal::Uint(32968) },
23174 ConstantSpec { name: c"BLEND_SRC_RGB", value: ConstantVal::Uint(32969) },
23175 ConstantSpec { name: c"BLEND_DST_ALPHA", value: ConstantVal::Uint(32970) },
23176 ConstantSpec { name: c"BLEND_SRC_ALPHA", value: ConstantVal::Uint(32971) },
23177 ConstantSpec { name: c"CONSTANT_COLOR", value: ConstantVal::Uint(32769) },
23178 ConstantSpec { name: c"ONE_MINUS_CONSTANT_COLOR", value: ConstantVal::Uint(32770) },
23179 ConstantSpec { name: c"CONSTANT_ALPHA", value: ConstantVal::Uint(32771) },
23180 ConstantSpec { name: c"ONE_MINUS_CONSTANT_ALPHA", value: ConstantVal::Uint(32772) },
23181 ConstantSpec { name: c"BLEND_COLOR", value: ConstantVal::Uint(32773) },
23182 ConstantSpec { name: c"ARRAY_BUFFER", value: ConstantVal::Uint(34962) },
23183 ConstantSpec { name: c"ELEMENT_ARRAY_BUFFER", value: ConstantVal::Uint(34963) },
23184 ConstantSpec { name: c"ARRAY_BUFFER_BINDING", value: ConstantVal::Uint(34964) },
23185 ConstantSpec { name: c"ELEMENT_ARRAY_BUFFER_BINDING", value: ConstantVal::Uint(34965) },
23186 ConstantSpec { name: c"STREAM_DRAW", value: ConstantVal::Uint(35040) },
23187 ConstantSpec { name: c"STATIC_DRAW", value: ConstantVal::Uint(35044) },
23188 ConstantSpec { name: c"DYNAMIC_DRAW", value: ConstantVal::Uint(35048) },
23189 ConstantSpec { name: c"BUFFER_SIZE", value: ConstantVal::Uint(34660) },
23190 ConstantSpec { name: c"BUFFER_USAGE", value: ConstantVal::Uint(34661) },
23191 ConstantSpec { name: c"CURRENT_VERTEX_ATTRIB", value: ConstantVal::Uint(34342) },
23192 ConstantSpec { name: c"FRONT", value: ConstantVal::Uint(1028) },
23193 ConstantSpec { name: c"BACK", value: ConstantVal::Uint(1029) },
23194 ConstantSpec { name: c"FRONT_AND_BACK", value: ConstantVal::Uint(1032) },
23195 ConstantSpec { name: c"CULL_FACE", value: ConstantVal::Uint(2884) },
23196 ConstantSpec { name: c"BLEND", value: ConstantVal::Uint(3042) },
23197 ConstantSpec { name: c"DITHER", value: ConstantVal::Uint(3024) },
23198 ConstantSpec { name: c"STENCIL_TEST", value: ConstantVal::Uint(2960) },
23199 ConstantSpec { name: c"DEPTH_TEST", value: ConstantVal::Uint(2929) },
23200 ConstantSpec { name: c"SCISSOR_TEST", value: ConstantVal::Uint(3089) },
23201 ConstantSpec { name: c"POLYGON_OFFSET_FILL", value: ConstantVal::Uint(32823) },
23202 ConstantSpec { name: c"SAMPLE_ALPHA_TO_COVERAGE", value: ConstantVal::Uint(32926) },
23203 ConstantSpec { name: c"SAMPLE_COVERAGE", value: ConstantVal::Uint(32928) },
23204 ConstantSpec { name: c"NO_ERROR", value: ConstantVal::Uint(0) },
23205 ConstantSpec { name: c"INVALID_ENUM", value: ConstantVal::Uint(1280) },
23206 ConstantSpec { name: c"INVALID_VALUE", value: ConstantVal::Uint(1281) },
23207 ConstantSpec { name: c"INVALID_OPERATION", value: ConstantVal::Uint(1282) },
23208 ConstantSpec { name: c"OUT_OF_MEMORY", value: ConstantVal::Uint(1285) },
23209 ConstantSpec { name: c"CW", value: ConstantVal::Uint(2304) },
23210 ConstantSpec { name: c"CCW", value: ConstantVal::Uint(2305) },
23211 ConstantSpec { name: c"LINE_WIDTH", value: ConstantVal::Uint(2849) },
23212 ConstantSpec { name: c"ALIASED_POINT_SIZE_RANGE", value: ConstantVal::Uint(33901) },
23213 ConstantSpec { name: c"ALIASED_LINE_WIDTH_RANGE", value: ConstantVal::Uint(33902) },
23214 ConstantSpec { name: c"CULL_FACE_MODE", value: ConstantVal::Uint(2885) },
23215 ConstantSpec { name: c"FRONT_FACE", value: ConstantVal::Uint(2886) },
23216 ConstantSpec { name: c"DEPTH_RANGE", value: ConstantVal::Uint(2928) },
23217 ConstantSpec { name: c"DEPTH_WRITEMASK", value: ConstantVal::Uint(2930) },
23218 ConstantSpec { name: c"DEPTH_CLEAR_VALUE", value: ConstantVal::Uint(2931) },
23219 ConstantSpec { name: c"DEPTH_FUNC", value: ConstantVal::Uint(2932) },
23220 ConstantSpec { name: c"STENCIL_CLEAR_VALUE", value: ConstantVal::Uint(2961) },
23221 ConstantSpec { name: c"STENCIL_FUNC", value: ConstantVal::Uint(2962) },
23222 ConstantSpec { name: c"STENCIL_FAIL", value: ConstantVal::Uint(2964) },
23223 ConstantSpec { name: c"STENCIL_PASS_DEPTH_FAIL", value: ConstantVal::Uint(2965) },
23224 ConstantSpec { name: c"STENCIL_PASS_DEPTH_PASS", value: ConstantVal::Uint(2966) },
23225 ConstantSpec { name: c"STENCIL_REF", value: ConstantVal::Uint(2967) },
23226 ConstantSpec { name: c"STENCIL_VALUE_MASK", value: ConstantVal::Uint(2963) },
23227 ConstantSpec { name: c"STENCIL_WRITEMASK", value: ConstantVal::Uint(2968) },
23228 ConstantSpec { name: c"STENCIL_BACK_FUNC", value: ConstantVal::Uint(34816) },
23229 ConstantSpec { name: c"STENCIL_BACK_FAIL", value: ConstantVal::Uint(34817) },
23230 ConstantSpec { name: c"STENCIL_BACK_PASS_DEPTH_FAIL", value: ConstantVal::Uint(34818) },
23231 ConstantSpec { name: c"STENCIL_BACK_PASS_DEPTH_PASS", value: ConstantVal::Uint(34819) },
23232 ConstantSpec { name: c"STENCIL_BACK_REF", value: ConstantVal::Uint(36003) },
23233 ConstantSpec { name: c"STENCIL_BACK_VALUE_MASK", value: ConstantVal::Uint(36004) },
23234 ConstantSpec { name: c"STENCIL_BACK_WRITEMASK", value: ConstantVal::Uint(36005) },
23235 ConstantSpec { name: c"VIEWPORT", value: ConstantVal::Uint(2978) },
23236 ConstantSpec { name: c"SCISSOR_BOX", value: ConstantVal::Uint(3088) },
23237 ConstantSpec { name: c"COLOR_CLEAR_VALUE", value: ConstantVal::Uint(3106) },
23238 ConstantSpec { name: c"COLOR_WRITEMASK", value: ConstantVal::Uint(3107) },
23239 ConstantSpec { name: c"UNPACK_ALIGNMENT", value: ConstantVal::Uint(3317) },
23240 ConstantSpec { name: c"PACK_ALIGNMENT", value: ConstantVal::Uint(3333) },
23241 ConstantSpec { name: c"MAX_TEXTURE_SIZE", value: ConstantVal::Uint(3379) },
23242 ConstantSpec { name: c"MAX_VIEWPORT_DIMS", value: ConstantVal::Uint(3386) },
23243 ConstantSpec { name: c"SUBPIXEL_BITS", value: ConstantVal::Uint(3408) },
23244 ConstantSpec { name: c"RED_BITS", value: ConstantVal::Uint(3410) },
23245 ConstantSpec { name: c"GREEN_BITS", value: ConstantVal::Uint(3411) },
23246 ConstantSpec { name: c"BLUE_BITS", value: ConstantVal::Uint(3412) },
23247 ConstantSpec { name: c"ALPHA_BITS", value: ConstantVal::Uint(3413) },
23248 ConstantSpec { name: c"DEPTH_BITS", value: ConstantVal::Uint(3414) },
23249 ConstantSpec { name: c"STENCIL_BITS", value: ConstantVal::Uint(3415) },
23250 ConstantSpec { name: c"POLYGON_OFFSET_UNITS", value: ConstantVal::Uint(10752) },
23251 ConstantSpec { name: c"POLYGON_OFFSET_FACTOR", value: ConstantVal::Uint(32824) },
23252 ConstantSpec { name: c"TEXTURE_BINDING_2D", value: ConstantVal::Uint(32873) },
23253 ConstantSpec { name: c"SAMPLE_BUFFERS", value: ConstantVal::Uint(32936) },
23254 ConstantSpec { name: c"SAMPLES", value: ConstantVal::Uint(32937) },
23255 ConstantSpec { name: c"SAMPLE_COVERAGE_VALUE", value: ConstantVal::Uint(32938) },
23256 ConstantSpec { name: c"SAMPLE_COVERAGE_INVERT", value: ConstantVal::Uint(32939) },
23257 ConstantSpec { name: c"COMPRESSED_TEXTURE_FORMATS", value: ConstantVal::Uint(34467) },
23258 ConstantSpec { name: c"DONT_CARE", value: ConstantVal::Uint(4352) },
23259 ConstantSpec { name: c"FASTEST", value: ConstantVal::Uint(4353) },
23260 ConstantSpec { name: c"NICEST", value: ConstantVal::Uint(4354) },
23261 ConstantSpec { name: c"GENERATE_MIPMAP_HINT", value: ConstantVal::Uint(33170) },
23262 ConstantSpec { name: c"BYTE", value: ConstantVal::Uint(5120) },
23263 ConstantSpec { name: c"UNSIGNED_BYTE", value: ConstantVal::Uint(5121) },
23264 ConstantSpec { name: c"SHORT", value: ConstantVal::Uint(5122) },
23265 ConstantSpec { name: c"UNSIGNED_SHORT", value: ConstantVal::Uint(5123) },
23266 ConstantSpec { name: c"INT", value: ConstantVal::Uint(5124) },
23267 ConstantSpec { name: c"UNSIGNED_INT", value: ConstantVal::Uint(5125) },
23268 ConstantSpec { name: c"FLOAT", value: ConstantVal::Uint(5126) },
23269 ConstantSpec { name: c"DEPTH_COMPONENT", value: ConstantVal::Uint(6402) },
23270 ConstantSpec { name: c"ALPHA", value: ConstantVal::Uint(6406) },
23271 ConstantSpec { name: c"RGB", value: ConstantVal::Uint(6407) },
23272 ConstantSpec { name: c"RGBA", value: ConstantVal::Uint(6408) },
23273 ConstantSpec { name: c"LUMINANCE", value: ConstantVal::Uint(6409) },
23274 ConstantSpec { name: c"LUMINANCE_ALPHA", value: ConstantVal::Uint(6410) },
23275 ConstantSpec { name: c"UNSIGNED_SHORT_4_4_4_4", value: ConstantVal::Uint(32819) },
23276 ConstantSpec { name: c"UNSIGNED_SHORT_5_5_5_1", value: ConstantVal::Uint(32820) },
23277 ConstantSpec { name: c"UNSIGNED_SHORT_5_6_5", value: ConstantVal::Uint(33635) },
23278 ConstantSpec { name: c"FRAGMENT_SHADER", value: ConstantVal::Uint(35632) },
23279 ConstantSpec { name: c"VERTEX_SHADER", value: ConstantVal::Uint(35633) },
23280 ConstantSpec { name: c"MAX_VERTEX_ATTRIBS", value: ConstantVal::Uint(34921) },
23281 ConstantSpec { name: c"MAX_VERTEX_UNIFORM_VECTORS", value: ConstantVal::Uint(36347) },
23282 ConstantSpec { name: c"MAX_VARYING_VECTORS", value: ConstantVal::Uint(36348) },
23283 ConstantSpec { name: c"MAX_COMBINED_TEXTURE_IMAGE_UNITS", value: ConstantVal::Uint(35661) },
23284 ConstantSpec { name: c"MAX_VERTEX_TEXTURE_IMAGE_UNITS", value: ConstantVal::Uint(35660) },
23285 ConstantSpec { name: c"MAX_TEXTURE_IMAGE_UNITS", value: ConstantVal::Uint(34930) },
23286 ConstantSpec { name: c"MAX_FRAGMENT_UNIFORM_VECTORS", value: ConstantVal::Uint(36349) },
23287 ConstantSpec { name: c"SHADER_TYPE", value: ConstantVal::Uint(35663) },
23288 ConstantSpec { name: c"DELETE_STATUS", value: ConstantVal::Uint(35712) },
23289 ConstantSpec { name: c"LINK_STATUS", value: ConstantVal::Uint(35714) },
23290 ConstantSpec { name: c"VALIDATE_STATUS", value: ConstantVal::Uint(35715) },
23291 ConstantSpec { name: c"ATTACHED_SHADERS", value: ConstantVal::Uint(35717) },
23292 ConstantSpec { name: c"ACTIVE_UNIFORMS", value: ConstantVal::Uint(35718) },
23293 ConstantSpec { name: c"ACTIVE_ATTRIBUTES", value: ConstantVal::Uint(35721) },
23294 ConstantSpec { name: c"SHADING_LANGUAGE_VERSION", value: ConstantVal::Uint(35724) },
23295 ConstantSpec { name: c"CURRENT_PROGRAM", value: ConstantVal::Uint(35725) },
23296 ConstantSpec { name: c"NEVER", value: ConstantVal::Uint(512) },
23297 ConstantSpec { name: c"LESS", value: ConstantVal::Uint(513) },
23298 ConstantSpec { name: c"EQUAL", value: ConstantVal::Uint(514) },
23299 ConstantSpec { name: c"LEQUAL", value: ConstantVal::Uint(515) },
23300 ConstantSpec { name: c"GREATER", value: ConstantVal::Uint(516) },
23301 ConstantSpec { name: c"NOTEQUAL", value: ConstantVal::Uint(517) },
23302 ConstantSpec { name: c"GEQUAL", value: ConstantVal::Uint(518) },
23303 ConstantSpec { name: c"ALWAYS", value: ConstantVal::Uint(519) },
23304 ConstantSpec { name: c"KEEP", value: ConstantVal::Uint(7680) },
23305 ConstantSpec { name: c"REPLACE", value: ConstantVal::Uint(7681) },
23306 ConstantSpec { name: c"INCR", value: ConstantVal::Uint(7682) },
23307 ConstantSpec { name: c"DECR", value: ConstantVal::Uint(7683) },
23308 ConstantSpec { name: c"INVERT", value: ConstantVal::Uint(5386) },
23309 ConstantSpec { name: c"INCR_WRAP", value: ConstantVal::Uint(34055) },
23310 ConstantSpec { name: c"DECR_WRAP", value: ConstantVal::Uint(34056) },
23311 ConstantSpec { name: c"VENDOR", value: ConstantVal::Uint(7936) },
23312 ConstantSpec { name: c"RENDERER", value: ConstantVal::Uint(7937) },
23313 ConstantSpec { name: c"VERSION", value: ConstantVal::Uint(7938) },
23314 ConstantSpec { name: c"NEAREST", value: ConstantVal::Uint(9728) },
23315 ConstantSpec { name: c"LINEAR", value: ConstantVal::Uint(9729) },
23316 ConstantSpec { name: c"NEAREST_MIPMAP_NEAREST", value: ConstantVal::Uint(9984) },
23317 ConstantSpec { name: c"LINEAR_MIPMAP_NEAREST", value: ConstantVal::Uint(9985) },
23318 ConstantSpec { name: c"NEAREST_MIPMAP_LINEAR", value: ConstantVal::Uint(9986) },
23319 ConstantSpec { name: c"LINEAR_MIPMAP_LINEAR", value: ConstantVal::Uint(9987) },
23320 ConstantSpec { name: c"TEXTURE_MAG_FILTER", value: ConstantVal::Uint(10240) },
23321 ConstantSpec { name: c"TEXTURE_MIN_FILTER", value: ConstantVal::Uint(10241) },
23322 ConstantSpec { name: c"TEXTURE_WRAP_S", value: ConstantVal::Uint(10242) },
23323 ConstantSpec { name: c"TEXTURE_WRAP_T", value: ConstantVal::Uint(10243) },
23324 ConstantSpec { name: c"TEXTURE_2D", value: ConstantVal::Uint(3553) },
23325 ConstantSpec { name: c"TEXTURE", value: ConstantVal::Uint(5890) },
23326 ConstantSpec { name: c"TEXTURE_CUBE_MAP", value: ConstantVal::Uint(34067) },
23327 ConstantSpec { name: c"TEXTURE_BINDING_CUBE_MAP", value: ConstantVal::Uint(34068) },
23328 ConstantSpec { name: c"TEXTURE_CUBE_MAP_POSITIVE_X", value: ConstantVal::Uint(34069) },
23329 ConstantSpec { name: c"TEXTURE_CUBE_MAP_NEGATIVE_X", value: ConstantVal::Uint(34070) },
23330 ConstantSpec { name: c"TEXTURE_CUBE_MAP_POSITIVE_Y", value: ConstantVal::Uint(34071) },
23331 ConstantSpec { name: c"TEXTURE_CUBE_MAP_NEGATIVE_Y", value: ConstantVal::Uint(34072) },
23332 ConstantSpec { name: c"TEXTURE_CUBE_MAP_POSITIVE_Z", value: ConstantVal::Uint(34073) },
23333 ConstantSpec { name: c"TEXTURE_CUBE_MAP_NEGATIVE_Z", value: ConstantVal::Uint(34074) },
23334 ConstantSpec { name: c"MAX_CUBE_MAP_TEXTURE_SIZE", value: ConstantVal::Uint(34076) },
23335 ConstantSpec { name: c"TEXTURE0", value: ConstantVal::Uint(33984) },
23336 ConstantSpec { name: c"TEXTURE1", value: ConstantVal::Uint(33985) },
23337 ConstantSpec { name: c"TEXTURE2", value: ConstantVal::Uint(33986) },
23338 ConstantSpec { name: c"TEXTURE3", value: ConstantVal::Uint(33987) },
23339 ConstantSpec { name: c"TEXTURE4", value: ConstantVal::Uint(33988) },
23340 ConstantSpec { name: c"TEXTURE5", value: ConstantVal::Uint(33989) },
23341 ConstantSpec { name: c"TEXTURE6", value: ConstantVal::Uint(33990) },
23342 ConstantSpec { name: c"TEXTURE7", value: ConstantVal::Uint(33991) },
23343 ConstantSpec { name: c"TEXTURE8", value: ConstantVal::Uint(33992) },
23344 ConstantSpec { name: c"TEXTURE9", value: ConstantVal::Uint(33993) },
23345 ConstantSpec { name: c"TEXTURE10", value: ConstantVal::Uint(33994) },
23346 ConstantSpec { name: c"TEXTURE11", value: ConstantVal::Uint(33995) },
23347 ConstantSpec { name: c"TEXTURE12", value: ConstantVal::Uint(33996) },
23348 ConstantSpec { name: c"TEXTURE13", value: ConstantVal::Uint(33997) },
23349 ConstantSpec { name: c"TEXTURE14", value: ConstantVal::Uint(33998) },
23350 ConstantSpec { name: c"TEXTURE15", value: ConstantVal::Uint(33999) },
23351 ConstantSpec { name: c"TEXTURE16", value: ConstantVal::Uint(34000) },
23352 ConstantSpec { name: c"TEXTURE17", value: ConstantVal::Uint(34001) },
23353 ConstantSpec { name: c"TEXTURE18", value: ConstantVal::Uint(34002) },
23354 ConstantSpec { name: c"TEXTURE19", value: ConstantVal::Uint(34003) },
23355 ConstantSpec { name: c"TEXTURE20", value: ConstantVal::Uint(34004) },
23356 ConstantSpec { name: c"TEXTURE21", value: ConstantVal::Uint(34005) },
23357 ConstantSpec { name: c"TEXTURE22", value: ConstantVal::Uint(34006) },
23358 ConstantSpec { name: c"TEXTURE23", value: ConstantVal::Uint(34007) },
23359 ConstantSpec { name: c"TEXTURE24", value: ConstantVal::Uint(34008) },
23360 ConstantSpec { name: c"TEXTURE25", value: ConstantVal::Uint(34009) },
23361 ConstantSpec { name: c"TEXTURE26", value: ConstantVal::Uint(34010) },
23362 ConstantSpec { name: c"TEXTURE27", value: ConstantVal::Uint(34011) },
23363 ConstantSpec { name: c"TEXTURE28", value: ConstantVal::Uint(34012) },
23364 ConstantSpec { name: c"TEXTURE29", value: ConstantVal::Uint(34013) },
23365 ConstantSpec { name: c"TEXTURE30", value: ConstantVal::Uint(34014) },
23366 ConstantSpec { name: c"TEXTURE31", value: ConstantVal::Uint(34015) },
23367 ConstantSpec { name: c"ACTIVE_TEXTURE", value: ConstantVal::Uint(34016) },
23368 ConstantSpec { name: c"REPEAT", value: ConstantVal::Uint(10497) },
23369 ConstantSpec { name: c"CLAMP_TO_EDGE", value: ConstantVal::Uint(33071) },
23370 ConstantSpec { name: c"MIRRORED_REPEAT", value: ConstantVal::Uint(33648) },
23371 ConstantSpec { name: c"FLOAT_VEC2", value: ConstantVal::Uint(35664) },
23372 ConstantSpec { name: c"FLOAT_VEC3", value: ConstantVal::Uint(35665) },
23373 ConstantSpec { name: c"FLOAT_VEC4", value: ConstantVal::Uint(35666) },
23374 ConstantSpec { name: c"INT_VEC2", value: ConstantVal::Uint(35667) },
23375 ConstantSpec { name: c"INT_VEC3", value: ConstantVal::Uint(35668) },
23376 ConstantSpec { name: c"INT_VEC4", value: ConstantVal::Uint(35669) },
23377 ConstantSpec { name: c"BOOL", value: ConstantVal::Uint(35670) },
23378 ConstantSpec { name: c"BOOL_VEC2", value: ConstantVal::Uint(35671) },
23379 ConstantSpec { name: c"BOOL_VEC3", value: ConstantVal::Uint(35672) },
23380 ConstantSpec { name: c"BOOL_VEC4", value: ConstantVal::Uint(35673) },
23381 ConstantSpec { name: c"FLOAT_MAT2", value: ConstantVal::Uint(35674) },
23382 ConstantSpec { name: c"FLOAT_MAT3", value: ConstantVal::Uint(35675) },
23383 ConstantSpec { name: c"FLOAT_MAT4", value: ConstantVal::Uint(35676) },
23384 ConstantSpec { name: c"SAMPLER_2D", value: ConstantVal::Uint(35678) },
23385 ConstantSpec { name: c"SAMPLER_CUBE", value: ConstantVal::Uint(35680) },
23386 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_ENABLED", value: ConstantVal::Uint(34338) },
23387 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_SIZE", value: ConstantVal::Uint(34339) },
23388 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_STRIDE", value: ConstantVal::Uint(34340) },
23389 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_TYPE", value: ConstantVal::Uint(34341) },
23390 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_NORMALIZED", value: ConstantVal::Uint(34922) },
23391 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_POINTER", value: ConstantVal::Uint(34373) },
23392 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", value: ConstantVal::Uint(34975) },
23393 ConstantSpec { name: c"IMPLEMENTATION_COLOR_READ_TYPE", value: ConstantVal::Uint(35738) },
23394 ConstantSpec { name: c"IMPLEMENTATION_COLOR_READ_FORMAT", value: ConstantVal::Uint(35739) },
23395 ConstantSpec { name: c"COMPILE_STATUS", value: ConstantVal::Uint(35713) },
23396 ConstantSpec { name: c"LOW_FLOAT", value: ConstantVal::Uint(36336) },
23397 ConstantSpec { name: c"MEDIUM_FLOAT", value: ConstantVal::Uint(36337) },
23398 ConstantSpec { name: c"HIGH_FLOAT", value: ConstantVal::Uint(36338) },
23399 ConstantSpec { name: c"LOW_INT", value: ConstantVal::Uint(36339) },
23400 ConstantSpec { name: c"MEDIUM_INT", value: ConstantVal::Uint(36340) },
23401 ConstantSpec { name: c"HIGH_INT", value: ConstantVal::Uint(36341) },
23402 ConstantSpec { name: c"FRAMEBUFFER", value: ConstantVal::Uint(36160) },
23403 ConstantSpec { name: c"RENDERBUFFER", value: ConstantVal::Uint(36161) },
23404 ConstantSpec { name: c"RGBA4", value: ConstantVal::Uint(32854) },
23405 ConstantSpec { name: c"RGB5_A1", value: ConstantVal::Uint(32855) },
23406 ConstantSpec { name: c"RGB565", value: ConstantVal::Uint(36194) },
23407 ConstantSpec { name: c"DEPTH_COMPONENT16", value: ConstantVal::Uint(33189) },
23408 ConstantSpec { name: c"STENCIL_INDEX8", value: ConstantVal::Uint(36168) },
23409 ConstantSpec { name: c"DEPTH_STENCIL", value: ConstantVal::Uint(34041) },
23410 ConstantSpec { name: c"RENDERBUFFER_WIDTH", value: ConstantVal::Uint(36162) },
23411 ConstantSpec { name: c"RENDERBUFFER_HEIGHT", value: ConstantVal::Uint(36163) },
23412 ConstantSpec { name: c"RENDERBUFFER_INTERNAL_FORMAT", value: ConstantVal::Uint(36164) },
23413 ConstantSpec { name: c"RENDERBUFFER_RED_SIZE", value: ConstantVal::Uint(36176) },
23414 ConstantSpec { name: c"RENDERBUFFER_GREEN_SIZE", value: ConstantVal::Uint(36177) },
23415 ConstantSpec { name: c"RENDERBUFFER_BLUE_SIZE", value: ConstantVal::Uint(36178) },
23416 ConstantSpec { name: c"RENDERBUFFER_ALPHA_SIZE", value: ConstantVal::Uint(36179) },
23417 ConstantSpec { name: c"RENDERBUFFER_DEPTH_SIZE", value: ConstantVal::Uint(36180) },
23418 ConstantSpec { name: c"RENDERBUFFER_STENCIL_SIZE", value: ConstantVal::Uint(36181) },
23419 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", value: ConstantVal::Uint(36048) },
23420 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", value: ConstantVal::Uint(36049) },
23421 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", value: ConstantVal::Uint(36050) },
23422 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", value: ConstantVal::Uint(36051) },
23423 ConstantSpec { name: c"COLOR_ATTACHMENT0", value: ConstantVal::Uint(36064) },
23424 ConstantSpec { name: c"DEPTH_ATTACHMENT", value: ConstantVal::Uint(36096) },
23425 ConstantSpec { name: c"STENCIL_ATTACHMENT", value: ConstantVal::Uint(36128) },
23426 ConstantSpec { name: c"DEPTH_STENCIL_ATTACHMENT", value: ConstantVal::Uint(33306) },
23427 ConstantSpec { name: c"NONE", value: ConstantVal::Uint(0) },
23428 ConstantSpec { name: c"FRAMEBUFFER_COMPLETE", value: ConstantVal::Uint(36053) },
23429 ConstantSpec { name: c"FRAMEBUFFER_INCOMPLETE_ATTACHMENT", value: ConstantVal::Uint(36054) },
23430 ConstantSpec { name: c"FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", value: ConstantVal::Uint(36055) },
23431 ConstantSpec { name: c"FRAMEBUFFER_INCOMPLETE_DIMENSIONS", value: ConstantVal::Uint(36057) },
23432 ConstantSpec { name: c"FRAMEBUFFER_UNSUPPORTED", value: ConstantVal::Uint(36061) },
23433 ConstantSpec { name: c"FRAMEBUFFER_BINDING", value: ConstantVal::Uint(36006) },
23434 ConstantSpec { name: c"RENDERBUFFER_BINDING", value: ConstantVal::Uint(36007) },
23435 ConstantSpec { name: c"MAX_RENDERBUFFER_SIZE", value: ConstantVal::Uint(34024) },
23436 ConstantSpec { name: c"INVALID_FRAMEBUFFER_OPERATION", value: ConstantVal::Uint(1286) },
23437 ConstantSpec { name: c"UNPACK_FLIP_Y_WEBGL", value: ConstantVal::Uint(37440) },
23438 ConstantSpec { name: c"UNPACK_PREMULTIPLY_ALPHA_WEBGL", value: ConstantVal::Uint(37441) },
23439 ConstantSpec { name: c"CONTEXT_LOST_WEBGL", value: ConstantVal::Uint(37442) },
23440 ConstantSpec { name: c"UNPACK_COLORSPACE_CONVERSION_WEBGL", value: ConstantVal::Uint(37443) },
23441 ConstantSpec { name: c"BROWSER_DEFAULT_WEBGL", value: ConstantVal::Uint(37444) }]))[..]
23442])));
23443}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();
23444
23445pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
23446 sConstants.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sConstants_specs.get() })[0]),
23447 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[1])])));
23448}
23449pub fn GetProtoObject<D: DomTypes>
23450(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
23451 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WebGL2RenderingContext), CreateInterfaceObjects::<D>, rval)
23453}
23454
23455
23456static PrototypeClass: JSClass = JSClass {
23457 name: c"WebGL2RenderingContextPrototype".as_ptr(),
23458 flags:
23459 (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
23461 cOps: ptr::null(),
23462 spec: ptr::null(),
23463 ext: ptr::null(),
23464 oOps: ptr::null(),
23465};
23466
23467
23468static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();
23469
23470pub(crate) fn init_interface_object<D: DomTypes>() {
23471 INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
23472 Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
23473 b"function WebGL2RenderingContext() {\n [native code]\n}",
23474 PrototypeList::ID::WebGL2RenderingContext,
23475 0,
23476 ));
23477}
23478
23479pub fn DefineDOMInterface<D: DomTypes>
23480(cx: SafeJSContext, global: HandleObject){
23481 define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WebGL2RenderingContext),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
23482}
23483
23484pub fn ConstructorEnabled<D: DomTypes>
23485(aCx: SafeJSContext, aObj: HandleObject) -> bool{
23486 is_exposed_in(aObj, Globals::WINDOW) &&
23487 D::WebGL2RenderingContext::is_webgl2_enabled(aCx, aObj)
23488}
23489
23490unsafe fn CreateInterfaceObjects<D: DomTypes>
23491(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
23492
23493 rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
23494 prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
23495 assert!(!prototype_proto.is_null());
23496
23497 rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
23498 create_interface_prototype_object::<D>(cx,
23499 global,
23500 prototype_proto.handle(),
23501 &PrototypeClass,
23502 sMethods.get(),
23503 sAttributes.get(),
23504 sConstants.get(),
23505 &[],
23506 prototype.handle_mut());
23507 assert!(!prototype.is_null());
23508 assert!((*cache)[PrototypeList::ID::WebGL2RenderingContext as usize].is_null());
23509 (*cache)[PrototypeList::ID::WebGL2RenderingContext as usize] = prototype.get();
23510 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::WebGL2RenderingContext as isize),
23511 ptr::null_mut(),
23512 prototype.get());
23513
23514 rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
23515 interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));
23516
23517 assert!(!interface_proto.is_null());
23518
23519 rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
23520 create_noncallback_interface_object::<D>(cx,
23521 global,
23522 interface_proto.handle(),
23523 INTERFACE_OBJECT_CLASS.get(),
23524 &[],
23525 &[],
23526 sConstants.get(),
23527 prototype.handle(),
23528 c"WebGL2RenderingContext",
23529 0,
23530 &[],
23531 interface.handle_mut());
23532 assert!(!interface.is_null());
23533}
23534
23535
23536 pub(crate) fn init_statics<D: DomTypes>() {
23537 init_interface_object::<D>();
23538 init_domjs_class::<D>();
23539 crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_copyBufferSubData_methodinfo::<D>();
23540crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getBufferSubData_methodinfo::<D>();
23541crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_blitFramebuffer_methodinfo::<D>();
23542crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_framebufferTextureLayer_methodinfo::<D>();
23543crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_invalidateFramebuffer_methodinfo::<D>();
23544crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_invalidateSubFramebuffer_methodinfo::<D>();
23545crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_readBuffer_methodinfo::<D>();
23546crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getInternalformatParameter_methodinfo::<D>();
23547crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_renderbufferStorageMultisample_methodinfo::<D>();
23548crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_texStorage2D_methodinfo::<D>();
23549crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_texStorage3D_methodinfo::<D>();
23550crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_texImage3D_methodinfo::<D>();
23551crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getFragDataLocation_methodinfo::<D>();
23552crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform1ui_methodinfo::<D>();
23553crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform2ui_methodinfo::<D>();
23554crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform3ui_methodinfo::<D>();
23555crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform4ui_methodinfo::<D>();
23556crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform1uiv_methodinfo::<D>();
23557crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform2uiv_methodinfo::<D>();
23558crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform3uiv_methodinfo::<D>();
23559crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform4uiv_methodinfo::<D>();
23560crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix3x2fv_methodinfo::<D>();
23561crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix4x2fv_methodinfo::<D>();
23562crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix2x3fv_methodinfo::<D>();
23563crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix4x3fv_methodinfo::<D>();
23564crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix2x4fv_methodinfo::<D>();
23565crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix3x4fv_methodinfo::<D>();
23566crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttribI4i_methodinfo::<D>();
23567crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttribI4iv_methodinfo::<D>();
23568crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttribI4ui_methodinfo::<D>();
23569crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttribI4uiv_methodinfo::<D>();
23570crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttribIPointer_methodinfo::<D>();
23571crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttribDivisor_methodinfo::<D>();
23572crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_drawArraysInstanced_methodinfo::<D>();
23573crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_drawElementsInstanced_methodinfo::<D>();
23574crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_drawRangeElements_methodinfo::<D>();
23575crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_drawBuffers_methodinfo::<D>();
23576crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clearBufferfv_methodinfo::<D>();
23577crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clearBufferiv_methodinfo::<D>();
23578crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clearBufferuiv_methodinfo::<D>();
23579crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clearBufferfi_methodinfo::<D>();
23580crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createQuery_methodinfo::<D>();
23581crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteQuery_methodinfo::<D>();
23582crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isQuery_methodinfo::<D>();
23583crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_beginQuery_methodinfo::<D>();
23584crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_endQuery_methodinfo::<D>();
23585crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getQuery_methodinfo::<D>();
23586crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getQueryParameter_methodinfo::<D>();
23587crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createSampler_methodinfo::<D>();
23588crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteSampler_methodinfo::<D>();
23589crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isSampler_methodinfo::<D>();
23590crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindSampler_methodinfo::<D>();
23591crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_samplerParameteri_methodinfo::<D>();
23592crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_samplerParameterf_methodinfo::<D>();
23593crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getSamplerParameter_methodinfo::<D>();
23594crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_fenceSync_methodinfo::<D>();
23595crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isSync_methodinfo::<D>();
23596crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteSync_methodinfo::<D>();
23597crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clientWaitSync_methodinfo::<D>();
23598crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_waitSync_methodinfo::<D>();
23599crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getSyncParameter_methodinfo::<D>();
23600crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createTransformFeedback_methodinfo::<D>();
23601crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteTransformFeedback_methodinfo::<D>();
23602crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isTransformFeedback_methodinfo::<D>();
23603crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindTransformFeedback_methodinfo::<D>();
23604crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_beginTransformFeedback_methodinfo::<D>();
23605crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_endTransformFeedback_methodinfo::<D>();
23606crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_transformFeedbackVaryings_methodinfo::<D>();
23607crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getTransformFeedbackVarying_methodinfo::<D>();
23608crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_pauseTransformFeedback_methodinfo::<D>();
23609crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_resumeTransformFeedback_methodinfo::<D>();
23610crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindBufferBase_methodinfo::<D>();
23611crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindBufferRange_methodinfo::<D>();
23612crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getIndexedParameter_methodinfo::<D>();
23613crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getUniformIndices_methodinfo::<D>();
23614crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getActiveUniforms_methodinfo::<D>();
23615crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getUniformBlockIndex_methodinfo::<D>();
23616crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getActiveUniformBlockParameter_methodinfo::<D>();
23617crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getActiveUniformBlockName_methodinfo::<D>();
23618crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformBlockBinding_methodinfo::<D>();
23619crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createVertexArray_methodinfo::<D>();
23620crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteVertexArray_methodinfo::<D>();
23621crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isVertexArray_methodinfo::<D>();
23622crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindVertexArray_methodinfo::<D>();
23623crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bufferData_methodinfo::<D>();
23624crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bufferSubData_methodinfo::<D>();
23625crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_texImage2D_methodinfo::<D>();
23626crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_texSubImage2D_methodinfo::<D>();
23627crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_compressedTexImage2D_methodinfo::<D>();
23628crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_compressedTexSubImage2D_methodinfo::<D>();
23629crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform1fv_methodinfo::<D>();
23630crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform2fv_methodinfo::<D>();
23631crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform3fv_methodinfo::<D>();
23632crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform4fv_methodinfo::<D>();
23633crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform1iv_methodinfo::<D>();
23634crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform2iv_methodinfo::<D>();
23635crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform3iv_methodinfo::<D>();
23636crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform4iv_methodinfo::<D>();
23637crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix2fv_methodinfo::<D>();
23638crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix3fv_methodinfo::<D>();
23639crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniformMatrix4fv_methodinfo::<D>();
23640crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_readPixels_methodinfo::<D>();
23641crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getContextAttributes_methodinfo::<D>();
23642crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isContextLost_methodinfo::<D>();
23643crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getSupportedExtensions_methodinfo::<D>();
23644crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getExtension_methodinfo::<D>();
23645crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_activeTexture_methodinfo::<D>();
23646crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_attachShader_methodinfo::<D>();
23647crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindAttribLocation_methodinfo::<D>();
23648crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindBuffer_methodinfo::<D>();
23649crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindFramebuffer_methodinfo::<D>();
23650crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindRenderbuffer_methodinfo::<D>();
23651crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_bindTexture_methodinfo::<D>();
23652crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_blendColor_methodinfo::<D>();
23653crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_blendEquation_methodinfo::<D>();
23654crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_blendEquationSeparate_methodinfo::<D>();
23655crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_blendFunc_methodinfo::<D>();
23656crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_blendFuncSeparate_methodinfo::<D>();
23657crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_checkFramebufferStatus_methodinfo::<D>();
23658crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clear_methodinfo::<D>();
23659crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clearColor_methodinfo::<D>();
23660crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clearDepth_methodinfo::<D>();
23661crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_clearStencil_methodinfo::<D>();
23662crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_colorMask_methodinfo::<D>();
23663crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_compileShader_methodinfo::<D>();
23664crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_copyTexImage2D_methodinfo::<D>();
23665crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_copyTexSubImage2D_methodinfo::<D>();
23666crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createBuffer_methodinfo::<D>();
23667crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createFramebuffer_methodinfo::<D>();
23668crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createProgram_methodinfo::<D>();
23669crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createRenderbuffer_methodinfo::<D>();
23670crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createShader_methodinfo::<D>();
23671crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_createTexture_methodinfo::<D>();
23672crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_cullFace_methodinfo::<D>();
23673crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteBuffer_methodinfo::<D>();
23674crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteFramebuffer_methodinfo::<D>();
23675crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteProgram_methodinfo::<D>();
23676crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteRenderbuffer_methodinfo::<D>();
23677crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteShader_methodinfo::<D>();
23678crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_deleteTexture_methodinfo::<D>();
23679crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_depthFunc_methodinfo::<D>();
23680crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_depthMask_methodinfo::<D>();
23681crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_depthRange_methodinfo::<D>();
23682crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_detachShader_methodinfo::<D>();
23683crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_disable_methodinfo::<D>();
23684crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_disableVertexAttribArray_methodinfo::<D>();
23685crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_drawArrays_methodinfo::<D>();
23686crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_drawElements_methodinfo::<D>();
23687crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_enable_methodinfo::<D>();
23688crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_enableVertexAttribArray_methodinfo::<D>();
23689crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_finish_methodinfo::<D>();
23690crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_flush_methodinfo::<D>();
23691crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_framebufferRenderbuffer_methodinfo::<D>();
23692crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_framebufferTexture2D_methodinfo::<D>();
23693crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_frontFace_methodinfo::<D>();
23694crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_generateMipmap_methodinfo::<D>();
23695crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getActiveAttrib_methodinfo::<D>();
23696crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getActiveUniform_methodinfo::<D>();
23697crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getAttachedShaders_methodinfo::<D>();
23698crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getAttribLocation_methodinfo::<D>();
23699crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getBufferParameter_methodinfo::<D>();
23700crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getParameter_methodinfo::<D>();
23701crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getError_methodinfo::<D>();
23702crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getFramebufferAttachmentParameter_methodinfo::<D>();
23703crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getProgramParameter_methodinfo::<D>();
23704crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getProgramInfoLog_methodinfo::<D>();
23705crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getRenderbufferParameter_methodinfo::<D>();
23706crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getShaderParameter_methodinfo::<D>();
23707crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getShaderPrecisionFormat_methodinfo::<D>();
23708crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getShaderInfoLog_methodinfo::<D>();
23709crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getShaderSource_methodinfo::<D>();
23710crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getTexParameter_methodinfo::<D>();
23711crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getUniform_methodinfo::<D>();
23712crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getUniformLocation_methodinfo::<D>();
23713crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getVertexAttrib_methodinfo::<D>();
23714crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_getVertexAttribOffset_methodinfo::<D>();
23715crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_hint_methodinfo::<D>();
23716crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isBuffer_methodinfo::<D>();
23717crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isEnabled_methodinfo::<D>();
23718crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isFramebuffer_methodinfo::<D>();
23719crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isProgram_methodinfo::<D>();
23720crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isRenderbuffer_methodinfo::<D>();
23721crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isShader_methodinfo::<D>();
23722crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_isTexture_methodinfo::<D>();
23723crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_lineWidth_methodinfo::<D>();
23724crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_linkProgram_methodinfo::<D>();
23725crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_pixelStorei_methodinfo::<D>();
23726crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_polygonOffset_methodinfo::<D>();
23727crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_renderbufferStorage_methodinfo::<D>();
23728crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_sampleCoverage_methodinfo::<D>();
23729crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_scissor_methodinfo::<D>();
23730crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_shaderSource_methodinfo::<D>();
23731crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_stencilFunc_methodinfo::<D>();
23732crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_stencilFuncSeparate_methodinfo::<D>();
23733crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_stencilMask_methodinfo::<D>();
23734crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_stencilMaskSeparate_methodinfo::<D>();
23735crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_stencilOp_methodinfo::<D>();
23736crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_stencilOpSeparate_methodinfo::<D>();
23737crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_texParameterf_methodinfo::<D>();
23738crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_texParameteri_methodinfo::<D>();
23739crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform1f_methodinfo::<D>();
23740crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform2f_methodinfo::<D>();
23741crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform3f_methodinfo::<D>();
23742crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform4f_methodinfo::<D>();
23743crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform1i_methodinfo::<D>();
23744crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform2i_methodinfo::<D>();
23745crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform3i_methodinfo::<D>();
23746crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_uniform4i_methodinfo::<D>();
23747crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_useProgram_methodinfo::<D>();
23748crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_validateProgram_methodinfo::<D>();
23749crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttrib1f_methodinfo::<D>();
23750crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttrib2f_methodinfo::<D>();
23751crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttrib3f_methodinfo::<D>();
23752crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttrib4f_methodinfo::<D>();
23753crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttrib1fv_methodinfo::<D>();
23754crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttrib2fv_methodinfo::<D>();
23755crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttrib3fv_methodinfo::<D>();
23756crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttrib4fv_methodinfo::<D>();
23757crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_vertexAttribPointer_methodinfo::<D>();
23758crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_viewport_methodinfo::<D>();
23759crate::codegen::GenericBindings::WebGL2RenderingContextBinding::WebGL2RenderingContext_Binding::init_makeXRCompatible_methodinfo::<D>();
23760 init_canvas_getterinfo::<D>();
23761init_drawingBufferWidth_getterinfo::<D>();
23762init_drawingBufferHeight_getterinfo::<D>();
23763
23764
23765 init_sMethods_specs::<D>();
23766init_sMethods_prefs::<D>();
23767init_sAttributes_specs::<D>();
23768init_sAttributes_prefs::<D>();
23769init_sConstants_specs::<D>();
23770init_sConstants_prefs::<D>();
23771 }
23772 }