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::import::base::*;
12
13pub type GLenum = u32;
14
15pub type GLboolean = bool;
16
17pub type GLbitfield = u32;
18
19pub type GLbyte = i8;
20
21pub type GLshort = i16;
22
23pub type GLint = i32;
24
25pub type GLsizei = i32;
26
27pub type GLintptr = i64;
28
29pub type GLsizeiptr = i64;
30
31pub type GLubyte = u8;
32
33pub type GLushort = u16;
34
35pub type GLuint = u32;
36
37pub type GLfloat = f32;
38
39pub type GLclampf = f32;
40
41pub use self::GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement as TexImageSource;
42
43pub use self::GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence as Float32List;
44
45pub use self::GenericUnionTypes::Int32ArrayOrLongSequence as Int32List;
46
47#[derive(JSTraceable)]
48pub struct WebGLContextAttributes {
49 pub alpha: bool,
50 pub antialias: bool,
51 pub depth: bool,
52 pub failIfMajorPerformanceCaveat: bool,
53 pub preferLowPowerToHighPerformance: bool,
54 pub premultipliedAlpha: bool,
55 pub preserveDrawingBuffer: bool,
56 pub stencil: bool,
57}
58impl Default for WebGLContextAttributes {
59 fn default() -> Self {
60 Self::empty()
61 }
62}
63
64impl WebGLContextAttributes {
65 pub fn empty() -> Self {
66 Self {
67 alpha: true,
68 antialias: true,
69 depth: true,
70 failIfMajorPerformanceCaveat: false,
71 preferLowPowerToHighPerformance: false,
72 premultipliedAlpha: true,
73 preserveDrawingBuffer: false,
74 stencil: false,
75 }
76 }
77 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
78 -> Result<ConversionResult<WebGLContextAttributes>, ()> {
79 unsafe {
80 let object = if val.get().is_null_or_undefined() {
81 ptr::null_mut()
82 } else if val.get().is_object() {
83 val.get().to_object()
84 } else {
85 return Ok(ConversionResult::Failure("Value is not an object.".into()));
86 };
87 rooted!(&in(cx) let object = object);
88 let dictionary = WebGLContextAttributes {
89 alpha: {
90 rooted!(&in(cx) let mut rval = UndefinedValue());
91 if get_dictionary_property(cx.raw_cx(), object.handle(), "alpha", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
92 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
93 Ok(ConversionResult::Success(value)) => value,
94 Ok(ConversionResult::Failure(error)) => {
95 throw_type_error(cx.raw_cx(), &error);
96 return Err(());
97
98 }
99 _ => {
100 return Err(());
101
102 },
103 }
104
105 } else {
106 true
107 }
108 },
109 antialias: {
110 rooted!(&in(cx) let mut rval = UndefinedValue());
111 if get_dictionary_property(cx.raw_cx(), object.handle(), "antialias", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
112 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
113 Ok(ConversionResult::Success(value)) => value,
114 Ok(ConversionResult::Failure(error)) => {
115 throw_type_error(cx.raw_cx(), &error);
116 return Err(());
117
118 }
119 _ => {
120 return Err(());
121
122 },
123 }
124
125 } else {
126 true
127 }
128 },
129 depth: {
130 rooted!(&in(cx) let mut rval = UndefinedValue());
131 if get_dictionary_property(cx.raw_cx(), object.handle(), "depth", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
132 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
133 Ok(ConversionResult::Success(value)) => value,
134 Ok(ConversionResult::Failure(error)) => {
135 throw_type_error(cx.raw_cx(), &error);
136 return Err(());
137
138 }
139 _ => {
140 return Err(());
141
142 },
143 }
144
145 } else {
146 true
147 }
148 },
149 failIfMajorPerformanceCaveat: {
150 rooted!(&in(cx) let mut rval = UndefinedValue());
151 if get_dictionary_property(cx.raw_cx(), object.handle(), "failIfMajorPerformanceCaveat", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
152 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
153 Ok(ConversionResult::Success(value)) => value,
154 Ok(ConversionResult::Failure(error)) => {
155 throw_type_error(cx.raw_cx(), &error);
156 return Err(());
157
158 }
159 _ => {
160 return Err(());
161
162 },
163 }
164
165 } else {
166 false
167 }
168 },
169 preferLowPowerToHighPerformance: {
170 rooted!(&in(cx) let mut rval = UndefinedValue());
171 if get_dictionary_property(cx.raw_cx(), object.handle(), "preferLowPowerToHighPerformance", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
172 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
173 Ok(ConversionResult::Success(value)) => value,
174 Ok(ConversionResult::Failure(error)) => {
175 throw_type_error(cx.raw_cx(), &error);
176 return Err(());
177
178 }
179 _ => {
180 return Err(());
181
182 },
183 }
184
185 } else {
186 false
187 }
188 },
189 premultipliedAlpha: {
190 rooted!(&in(cx) let mut rval = UndefinedValue());
191 if get_dictionary_property(cx.raw_cx(), object.handle(), "premultipliedAlpha", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
192 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
193 Ok(ConversionResult::Success(value)) => value,
194 Ok(ConversionResult::Failure(error)) => {
195 throw_type_error(cx.raw_cx(), &error);
196 return Err(());
197
198 }
199 _ => {
200 return Err(());
201
202 },
203 }
204
205 } else {
206 true
207 }
208 },
209 preserveDrawingBuffer: {
210 rooted!(&in(cx) let mut rval = UndefinedValue());
211 if get_dictionary_property(cx.raw_cx(), object.handle(), "preserveDrawingBuffer", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
212 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
213 Ok(ConversionResult::Success(value)) => value,
214 Ok(ConversionResult::Failure(error)) => {
215 throw_type_error(cx.raw_cx(), &error);
216 return Err(());
217
218 }
219 _ => {
220 return Err(());
221
222 },
223 }
224
225 } else {
226 false
227 }
228 },
229 stencil: {
230 rooted!(&in(cx) let mut rval = UndefinedValue());
231 if get_dictionary_property(cx.raw_cx(), object.handle(), "stencil", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
232 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
233 Ok(ConversionResult::Success(value)) => value,
234 Ok(ConversionResult::Failure(error)) => {
235 throw_type_error(cx.raw_cx(), &error);
236 return Err(());
237
238 }
239 _ => {
240 return Err(());
241
242 },
243 }
244
245 } else {
246 false
247 }
248 },
249 };
250 Ok(ConversionResult::Success(dictionary))
251 }
252 }
253}
254
255impl FromJSValConvertible for WebGLContextAttributes {
256 type Config = ();
257 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
258 -> Result<ConversionResult<WebGLContextAttributes>, ()> {
259 WebGLContextAttributes::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
260 }
261}
262
263impl WebGLContextAttributes {
264 #[allow(clippy::wrong_self_convention)]
265 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
266 let alpha = &self.alpha;
267 rooted!(in(cx) let mut alpha_js = UndefinedValue());
268 alpha.to_jsval(cx, alpha_js.handle_mut());
269 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "alpha", alpha_js.handle()).unwrap();
270 let antialias = &self.antialias;
271 rooted!(in(cx) let mut antialias_js = UndefinedValue());
272 antialias.to_jsval(cx, antialias_js.handle_mut());
273 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "antialias", antialias_js.handle()).unwrap();
274 let depth = &self.depth;
275 rooted!(in(cx) let mut depth_js = UndefinedValue());
276 depth.to_jsval(cx, depth_js.handle_mut());
277 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depth", depth_js.handle()).unwrap();
278 let failIfMajorPerformanceCaveat = &self.failIfMajorPerformanceCaveat;
279 rooted!(in(cx) let mut failIfMajorPerformanceCaveat_js = UndefinedValue());
280 failIfMajorPerformanceCaveat.to_jsval(cx, failIfMajorPerformanceCaveat_js.handle_mut());
281 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "failIfMajorPerformanceCaveat", failIfMajorPerformanceCaveat_js.handle()).unwrap();
282 let preferLowPowerToHighPerformance = &self.preferLowPowerToHighPerformance;
283 rooted!(in(cx) let mut preferLowPowerToHighPerformance_js = UndefinedValue());
284 preferLowPowerToHighPerformance.to_jsval(cx, preferLowPowerToHighPerformance_js.handle_mut());
285 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "preferLowPowerToHighPerformance", preferLowPowerToHighPerformance_js.handle()).unwrap();
286 let premultipliedAlpha = &self.premultipliedAlpha;
287 rooted!(in(cx) let mut premultipliedAlpha_js = UndefinedValue());
288 premultipliedAlpha.to_jsval(cx, premultipliedAlpha_js.handle_mut());
289 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "premultipliedAlpha", premultipliedAlpha_js.handle()).unwrap();
290 let preserveDrawingBuffer = &self.preserveDrawingBuffer;
291 rooted!(in(cx) let mut preserveDrawingBuffer_js = UndefinedValue());
292 preserveDrawingBuffer.to_jsval(cx, preserveDrawingBuffer_js.handle_mut());
293 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "preserveDrawingBuffer", preserveDrawingBuffer_js.handle()).unwrap();
294 let stencil = &self.stencil;
295 rooted!(in(cx) let mut stencil_js = UndefinedValue());
296 stencil.to_jsval(cx, stencil_js.handle_mut());
297 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencil", stencil_js.handle()).unwrap();
298 }
299}
300
301impl ToJSValConvertible for WebGLContextAttributes {
302 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
303 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
304 self.to_jsobject(cx, obj.handle_mut());
305 rval.set(ObjectOrNullValue(obj.get()))
306 }
307}
308
309
310pub use self::WebGLRenderingContext_Binding::{WebGLRenderingContextConstants, Wrap, WebGLRenderingContextMethods, GetProtoObject, DefineDOMInterface};
311pub mod WebGLRenderingContext_Binding {
312use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
313use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
314use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
315use crate::codegen::GenericBindings::HTMLMediaElementBinding::HTMLMediaElement_Binding;
316use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
317use crate::codegen::GenericBindings::WebGLObjectBinding::WebGLObject_Binding;
318use crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLContextAttributes;
319use crate::import::module::*;
320
321unsafe extern "C" fn get_canvas<D: DomTypes>
322(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
323 let mut result = false;
324 wrap_panic(&mut || result = (|| {
325 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
326 let this = &*(this as *const D::WebGLRenderingContext);
327 let result: GenericUnionTypes::HTMLCanvasElementOrOffscreenCanvas::<D> = this.Canvas();
328
329 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
330 return true;
331 })());
332 result
333}
334
335
336static canvas_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
337
338pub(crate) fn init_canvas_getterinfo<D: DomTypes>() {
339 canvas_getterinfo.set(JSJitInfo {
340 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
341 getter: Some(get_canvas::<D>)
342 },
343 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
344 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
345 },
346 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
347 _bitfield_align_1: [],
348 _bitfield_1: __BindgenBitfieldUnit::new(
349 new_jsjitinfo_bitfield_1!(
350 JSJitInfo_OpType::Getter as u8,
351 JSJitInfo_AliasSet::AliasEverything as u8,
352 JSValueType::JSVAL_TYPE_OBJECT as u8,
353 true,
354 false,
355 false,
356 false,
357 false,
358 false,
359 0,
360 ).to_ne_bytes()
361 ),
362});
363}
364unsafe extern "C" fn get_drawingBufferWidth<D: DomTypes>
365(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
366 let mut result = false;
367 wrap_panic(&mut || result = (|| {
368 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
369 let this = &*(this as *const D::WebGLRenderingContext);
370 let result: i32 = this.DrawingBufferWidth();
371
372 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
373 return true;
374 })());
375 result
376}
377
378
379static drawingBufferWidth_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
380
381pub(crate) fn init_drawingBufferWidth_getterinfo<D: DomTypes>() {
382 drawingBufferWidth_getterinfo.set(JSJitInfo {
383 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
384 getter: Some(get_drawingBufferWidth::<D>)
385 },
386 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
387 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
388 },
389 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
390 _bitfield_align_1: [],
391 _bitfield_1: __BindgenBitfieldUnit::new(
392 new_jsjitinfo_bitfield_1!(
393 JSJitInfo_OpType::Getter as u8,
394 JSJitInfo_AliasSet::AliasEverything as u8,
395 JSValueType::JSVAL_TYPE_INT32 as u8,
396 true,
397 false,
398 false,
399 false,
400 false,
401 false,
402 0,
403 ).to_ne_bytes()
404 ),
405});
406}
407unsafe extern "C" fn get_drawingBufferHeight<D: DomTypes>
408(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
409 let mut result = false;
410 wrap_panic(&mut || result = (|| {
411 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
412 let this = &*(this as *const D::WebGLRenderingContext);
413 let result: i32 = this.DrawingBufferHeight();
414
415 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
416 return true;
417 })());
418 result
419}
420
421
422static drawingBufferHeight_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
423
424pub(crate) fn init_drawingBufferHeight_getterinfo<D: DomTypes>() {
425 drawingBufferHeight_getterinfo.set(JSJitInfo {
426 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
427 getter: Some(get_drawingBufferHeight::<D>)
428 },
429 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
430 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
431 },
432 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
433 _bitfield_align_1: [],
434 _bitfield_1: __BindgenBitfieldUnit::new(
435 new_jsjitinfo_bitfield_1!(
436 JSJitInfo_OpType::Getter as u8,
437 JSJitInfo_AliasSet::AliasEverything as u8,
438 JSValueType::JSVAL_TYPE_INT32 as u8,
439 true,
440 false,
441 false,
442 false,
443 false,
444 false,
445 0,
446 ).to_ne_bytes()
447 ),
448});
449}
450unsafe extern "C" fn getContextAttributes<D: DomTypes>
451(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
452 let mut result = false;
453 wrap_panic(&mut || result = (|| {
454 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
455 let this = &*(this as *const D::WebGLRenderingContext);
456 let args = &*args;
457 let argc = args.argc_;
458 let result: Option<WebGLContextAttributes> = this.GetContextAttributes();
459
460 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
461 return true;
462 })());
463 result
464}
465
466
467static getContextAttributes_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
468
469pub(crate) fn init_getContextAttributes_methodinfo<D: DomTypes>() {
470 getContextAttributes_methodinfo.set(JSJitInfo {
471 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
472 method: Some(getContextAttributes::<D>)
473 },
474 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
475 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
476 },
477 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
478 _bitfield_align_1: [],
479 _bitfield_1: __BindgenBitfieldUnit::new(
480 new_jsjitinfo_bitfield_1!(
481 JSJitInfo_OpType::Method as u8,
482 JSJitInfo_AliasSet::AliasEverything as u8,
483 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
484 true,
485 false,
486 false,
487 false,
488 false,
489 false,
490 0,
491 ).to_ne_bytes()
492 ),
493});
494}
495unsafe extern "C" fn isContextLost<D: DomTypes>
496(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
497 let mut result = false;
498 wrap_panic(&mut || result = (|| {
499 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
500 let this = &*(this as *const D::WebGLRenderingContext);
501 let args = &*args;
502 let argc = args.argc_;
503 let result: bool = this.IsContextLost();
504
505 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
506 return true;
507 })());
508 result
509}
510
511
512static isContextLost_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
513
514pub(crate) fn init_isContextLost_methodinfo<D: DomTypes>() {
515 isContextLost_methodinfo.set(JSJitInfo {
516 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
517 method: Some(isContextLost::<D>)
518 },
519 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
520 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
521 },
522 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
523 _bitfield_align_1: [],
524 _bitfield_1: __BindgenBitfieldUnit::new(
525 new_jsjitinfo_bitfield_1!(
526 JSJitInfo_OpType::Method as u8,
527 JSJitInfo_AliasSet::AliasEverything as u8,
528 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
529 true,
530 false,
531 false,
532 false,
533 false,
534 false,
535 0,
536 ).to_ne_bytes()
537 ),
538});
539}
540unsafe extern "C" fn getSupportedExtensions<D: DomTypes>
541(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
542 let mut result = false;
543 wrap_panic(&mut || result = (|| {
544 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
545 let this = &*(this as *const D::WebGLRenderingContext);
546 let args = &*args;
547 let argc = args.argc_;
548 let result: Option<Vec<DOMString>> = this.GetSupportedExtensions();
549
550 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
551 return true;
552 })());
553 result
554}
555
556
557static getSupportedExtensions_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
558
559pub(crate) fn init_getSupportedExtensions_methodinfo<D: DomTypes>() {
560 getSupportedExtensions_methodinfo.set(JSJitInfo {
561 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
562 method: Some(getSupportedExtensions::<D>)
563 },
564 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
565 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
566 },
567 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
568 _bitfield_align_1: [],
569 _bitfield_1: __BindgenBitfieldUnit::new(
570 new_jsjitinfo_bitfield_1!(
571 JSJitInfo_OpType::Method as u8,
572 JSJitInfo_AliasSet::AliasEverything as u8,
573 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
574 true,
575 false,
576 false,
577 false,
578 false,
579 false,
580 0,
581 ).to_ne_bytes()
582 ),
583});
584}
585unsafe extern "C" fn getExtension<D: DomTypes>
586(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
587 let mut result = false;
588 wrap_panic(&mut || result = (|| {
589 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
590 let this = &*(this as *const D::WebGLRenderingContext);
591 let args = &*args;
592 let argc = args.argc_;
593
594 if argc < 1 {
595 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getExtension\".");
596 return false;
597 }
598 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
599 Ok(ConversionResult::Success(value)) => value,
600 Ok(ConversionResult::Failure(error)) => {
601 throw_type_error(cx.raw_cx(), &error);
602 return false;
603
604 }
605 _ => {
606 return false;
607
608 },
609 }
610 ;
611 let result: Option<NonNull<JSObject>> = this.GetExtension(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
612
613 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
614 return true;
615 })());
616 result
617}
618
619
620static getExtension_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
621
622pub(crate) fn init_getExtension_methodinfo<D: DomTypes>() {
623 getExtension_methodinfo.set(JSJitInfo {
624 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
625 method: Some(getExtension::<D>)
626 },
627 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
628 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
629 },
630 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
631 _bitfield_align_1: [],
632 _bitfield_1: __BindgenBitfieldUnit::new(
633 new_jsjitinfo_bitfield_1!(
634 JSJitInfo_OpType::Method as u8,
635 JSJitInfo_AliasSet::AliasEverything as u8,
636 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
637 false,
638 false,
639 false,
640 false,
641 false,
642 false,
643 0,
644 ).to_ne_bytes()
645 ),
646});
647}
648unsafe extern "C" fn activeTexture<D: DomTypes>
649(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
650 let mut result = false;
651 wrap_panic(&mut || result = (|| {
652 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
653 let this = &*(this as *const D::WebGLRenderingContext);
654 let args = &*args;
655 let argc = args.argc_;
656
657 if argc < 1 {
658 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.activeTexture\".");
659 return false;
660 }
661 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
662 Ok(ConversionResult::Success(value)) => value,
663 Ok(ConversionResult::Failure(error)) => {
664 throw_type_error(cx.raw_cx(), &error);
665 return false;
666
667 }
668 _ => {
669 return false;
670
671 },
672 }
673 ;
674 let result: () = this.ActiveTexture(arg0);
675
676 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
677 return true;
678 })());
679 result
680}
681
682
683static activeTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
684
685pub(crate) fn init_activeTexture_methodinfo<D: DomTypes>() {
686 activeTexture_methodinfo.set(JSJitInfo {
687 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
688 method: Some(activeTexture::<D>)
689 },
690 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
691 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
692 },
693 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
694 _bitfield_align_1: [],
695 _bitfield_1: __BindgenBitfieldUnit::new(
696 new_jsjitinfo_bitfield_1!(
697 JSJitInfo_OpType::Method as u8,
698 JSJitInfo_AliasSet::AliasEverything as u8,
699 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
700 false,
701 false,
702 false,
703 false,
704 false,
705 false,
706 0,
707 ).to_ne_bytes()
708 ),
709});
710}
711unsafe extern "C" fn attachShader<D: DomTypes>
712(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
713 let mut result = false;
714 wrap_panic(&mut || result = (|| {
715 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
716 let this = &*(this as *const D::WebGLRenderingContext);
717 let args = &*args;
718 let argc = args.argc_;
719
720 if argc < 2 {
721 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.attachShader\".");
722 return false;
723 }
724 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
725 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
726 Ok(val) => val,
727 Err(()) => {
728 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
729 return false;
730
731 }
732 }
733
734 } else {
735 throw_type_error(cx.raw_cx(), "Value is not an object.");
736 return false;
737
738 };
739 let arg1: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(1)).get().is_object() {
740 match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
741 Ok(val) => val,
742 Err(()) => {
743 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
744 return false;
745
746 }
747 }
748
749 } else {
750 throw_type_error(cx.raw_cx(), "Value is not an object.");
751 return false;
752
753 };
754 let result: () = this.AttachShader(&arg0, &arg1);
755
756 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
757 return true;
758 })());
759 result
760}
761
762
763static attachShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
764
765pub(crate) fn init_attachShader_methodinfo<D: DomTypes>() {
766 attachShader_methodinfo.set(JSJitInfo {
767 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
768 method: Some(attachShader::<D>)
769 },
770 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
771 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
772 },
773 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
774 _bitfield_align_1: [],
775 _bitfield_1: __BindgenBitfieldUnit::new(
776 new_jsjitinfo_bitfield_1!(
777 JSJitInfo_OpType::Method as u8,
778 JSJitInfo_AliasSet::AliasEverything as u8,
779 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
780 false,
781 false,
782 false,
783 false,
784 false,
785 false,
786 0,
787 ).to_ne_bytes()
788 ),
789});
790}
791unsafe extern "C" fn bindAttribLocation<D: DomTypes>
792(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
793 let mut result = false;
794 wrap_panic(&mut || result = (|| {
795 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
796 let this = &*(this as *const D::WebGLRenderingContext);
797 let args = &*args;
798 let argc = args.argc_;
799
800 if argc < 3 {
801 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.bindAttribLocation\".");
802 return false;
803 }
804 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
805 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
806 Ok(val) => val,
807 Err(()) => {
808 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
809 return false;
810
811 }
812 }
813
814 } else {
815 throw_type_error(cx.raw_cx(), "Value is not an object.");
816 return false;
817
818 };
819 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
820 Ok(ConversionResult::Success(value)) => value,
821 Ok(ConversionResult::Failure(error)) => {
822 throw_type_error(cx.raw_cx(), &error);
823 return false;
824
825 }
826 _ => {
827 return false;
828
829 },
830 }
831 ;
832 let arg2: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), StringificationBehavior::Default) {
833 Ok(ConversionResult::Success(value)) => value,
834 Ok(ConversionResult::Failure(error)) => {
835 throw_type_error(cx.raw_cx(), &error);
836 return false;
837
838 }
839 _ => {
840 return false;
841
842 },
843 }
844 ;
845 let result: () = this.BindAttribLocation(&arg0, arg1, arg2);
846
847 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
848 return true;
849 })());
850 result
851}
852
853
854static bindAttribLocation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
855
856pub(crate) fn init_bindAttribLocation_methodinfo<D: DomTypes>() {
857 bindAttribLocation_methodinfo.set(JSJitInfo {
858 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
859 method: Some(bindAttribLocation::<D>)
860 },
861 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
862 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
863 },
864 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
865 _bitfield_align_1: [],
866 _bitfield_1: __BindgenBitfieldUnit::new(
867 new_jsjitinfo_bitfield_1!(
868 JSJitInfo_OpType::Method as u8,
869 JSJitInfo_AliasSet::AliasEverything as u8,
870 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
871 false,
872 false,
873 false,
874 false,
875 false,
876 false,
877 0,
878 ).to_ne_bytes()
879 ),
880});
881}
882unsafe extern "C" fn bindBuffer<D: DomTypes>
883(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
884 let mut result = false;
885 wrap_panic(&mut || result = (|| {
886 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
887 let this = &*(this as *const D::WebGLRenderingContext);
888 let args = &*args;
889 let argc = args.argc_;
890
891 if argc < 2 {
892 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.bindBuffer\".");
893 return false;
894 }
895 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
896 Ok(ConversionResult::Success(value)) => value,
897 Ok(ConversionResult::Failure(error)) => {
898 throw_type_error(cx.raw_cx(), &error);
899 return false;
900
901 }
902 _ => {
903 return false;
904
905 },
906 }
907 ;
908 let arg1: Option<DomRoot<D::WebGLBuffer>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
909 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
910 Ok(val) => val,
911 Err(()) => {
912 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLBuffer.");
913 return false;
914
915 }
916 }
917 )
918 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
919 None
920 } else {
921 throw_type_error(cx.raw_cx(), "Value is not an object.");
922 return false;
923
924 };
925 let result: () = this.BindBuffer(arg0, arg1.as_deref());
926
927 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
928 return true;
929 })());
930 result
931}
932
933
934static bindBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
935
936pub(crate) fn init_bindBuffer_methodinfo<D: DomTypes>() {
937 bindBuffer_methodinfo.set(JSJitInfo {
938 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
939 method: Some(bindBuffer::<D>)
940 },
941 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
942 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
943 },
944 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
945 _bitfield_align_1: [],
946 _bitfield_1: __BindgenBitfieldUnit::new(
947 new_jsjitinfo_bitfield_1!(
948 JSJitInfo_OpType::Method as u8,
949 JSJitInfo_AliasSet::AliasEverything as u8,
950 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
951 false,
952 false,
953 false,
954 false,
955 false,
956 false,
957 0,
958 ).to_ne_bytes()
959 ),
960});
961}
962unsafe extern "C" fn bindFramebuffer<D: DomTypes>
963(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
964 let mut result = false;
965 wrap_panic(&mut || result = (|| {
966 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
967 let this = &*(this as *const D::WebGLRenderingContext);
968 let args = &*args;
969 let argc = args.argc_;
970
971 if argc < 2 {
972 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.bindFramebuffer\".");
973 return false;
974 }
975 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
976 Ok(ConversionResult::Success(value)) => value,
977 Ok(ConversionResult::Failure(error)) => {
978 throw_type_error(cx.raw_cx(), &error);
979 return false;
980
981 }
982 _ => {
983 return false;
984
985 },
986 }
987 ;
988 let arg1: Option<DomRoot<D::WebGLFramebuffer>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
989 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
990 Ok(val) => val,
991 Err(()) => {
992 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLFramebuffer.");
993 return false;
994
995 }
996 }
997 )
998 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
999 None
1000 } else {
1001 throw_type_error(cx.raw_cx(), "Value is not an object.");
1002 return false;
1003
1004 };
1005 let result: () = this.BindFramebuffer(arg0, arg1.as_deref());
1006
1007 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1008 return true;
1009 })());
1010 result
1011}
1012
1013
1014static bindFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1015
1016pub(crate) fn init_bindFramebuffer_methodinfo<D: DomTypes>() {
1017 bindFramebuffer_methodinfo.set(JSJitInfo {
1018 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1019 method: Some(bindFramebuffer::<D>)
1020 },
1021 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1022 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1023 },
1024 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1025 _bitfield_align_1: [],
1026 _bitfield_1: __BindgenBitfieldUnit::new(
1027 new_jsjitinfo_bitfield_1!(
1028 JSJitInfo_OpType::Method as u8,
1029 JSJitInfo_AliasSet::AliasEverything as u8,
1030 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1031 false,
1032 false,
1033 false,
1034 false,
1035 false,
1036 false,
1037 0,
1038 ).to_ne_bytes()
1039 ),
1040});
1041}
1042unsafe extern "C" fn bindRenderbuffer<D: DomTypes>
1043(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1044 let mut result = false;
1045 wrap_panic(&mut || result = (|| {
1046 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1047 let this = &*(this as *const D::WebGLRenderingContext);
1048 let args = &*args;
1049 let argc = args.argc_;
1050
1051 if argc < 2 {
1052 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.bindRenderbuffer\".");
1053 return false;
1054 }
1055 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1056 Ok(ConversionResult::Success(value)) => value,
1057 Ok(ConversionResult::Failure(error)) => {
1058 throw_type_error(cx.raw_cx(), &error);
1059 return false;
1060
1061 }
1062 _ => {
1063 return false;
1064
1065 },
1066 }
1067 ;
1068 let arg1: Option<DomRoot<D::WebGLRenderbuffer>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
1069 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
1070 Ok(val) => val,
1071 Err(()) => {
1072 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLRenderbuffer.");
1073 return false;
1074
1075 }
1076 }
1077 )
1078 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
1079 None
1080 } else {
1081 throw_type_error(cx.raw_cx(), "Value is not an object.");
1082 return false;
1083
1084 };
1085 let result: () = this.BindRenderbuffer(arg0, arg1.as_deref());
1086
1087 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1088 return true;
1089 })());
1090 result
1091}
1092
1093
1094static bindRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1095
1096pub(crate) fn init_bindRenderbuffer_methodinfo<D: DomTypes>() {
1097 bindRenderbuffer_methodinfo.set(JSJitInfo {
1098 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1099 method: Some(bindRenderbuffer::<D>)
1100 },
1101 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1102 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1103 },
1104 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1105 _bitfield_align_1: [],
1106 _bitfield_1: __BindgenBitfieldUnit::new(
1107 new_jsjitinfo_bitfield_1!(
1108 JSJitInfo_OpType::Method as u8,
1109 JSJitInfo_AliasSet::AliasEverything as u8,
1110 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1111 false,
1112 false,
1113 false,
1114 false,
1115 false,
1116 false,
1117 0,
1118 ).to_ne_bytes()
1119 ),
1120});
1121}
1122unsafe extern "C" fn bindTexture<D: DomTypes>
1123(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1124 let mut result = false;
1125 wrap_panic(&mut || result = (|| {
1126 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1127 let this = &*(this as *const D::WebGLRenderingContext);
1128 let args = &*args;
1129 let argc = args.argc_;
1130
1131 if argc < 2 {
1132 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.bindTexture\".");
1133 return false;
1134 }
1135 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1136 Ok(ConversionResult::Success(value)) => value,
1137 Ok(ConversionResult::Failure(error)) => {
1138 throw_type_error(cx.raw_cx(), &error);
1139 return false;
1140
1141 }
1142 _ => {
1143 return false;
1144
1145 },
1146 }
1147 ;
1148 let arg1: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
1149 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
1150 Ok(val) => val,
1151 Err(()) => {
1152 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
1153 return false;
1154
1155 }
1156 }
1157 )
1158 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
1159 None
1160 } else {
1161 throw_type_error(cx.raw_cx(), "Value is not an object.");
1162 return false;
1163
1164 };
1165 let result: () = this.BindTexture(arg0, arg1.as_deref());
1166
1167 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1168 return true;
1169 })());
1170 result
1171}
1172
1173
1174static bindTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1175
1176pub(crate) fn init_bindTexture_methodinfo<D: DomTypes>() {
1177 bindTexture_methodinfo.set(JSJitInfo {
1178 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1179 method: Some(bindTexture::<D>)
1180 },
1181 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1182 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1183 },
1184 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1185 _bitfield_align_1: [],
1186 _bitfield_1: __BindgenBitfieldUnit::new(
1187 new_jsjitinfo_bitfield_1!(
1188 JSJitInfo_OpType::Method as u8,
1189 JSJitInfo_AliasSet::AliasEverything as u8,
1190 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1191 false,
1192 false,
1193 false,
1194 false,
1195 false,
1196 false,
1197 0,
1198 ).to_ne_bytes()
1199 ),
1200});
1201}
1202unsafe extern "C" fn blendColor<D: DomTypes>
1203(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1204 let mut result = false;
1205 wrap_panic(&mut || result = (|| {
1206 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1207 let this = &*(this as *const D::WebGLRenderingContext);
1208 let args = &*args;
1209 let argc = args.argc_;
1210
1211 if argc < 4 {
1212 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.blendColor\".");
1213 return false;
1214 }
1215 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1216 Ok(ConversionResult::Success(value)) => value,
1217 Ok(ConversionResult::Failure(error)) => {
1218 throw_type_error(cx.raw_cx(), &error);
1219 return false;
1220
1221 }
1222 _ => {
1223 return false;
1224
1225 },
1226 }
1227 ;
1228 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1229 Ok(ConversionResult::Success(value)) => value,
1230 Ok(ConversionResult::Failure(error)) => {
1231 throw_type_error(cx.raw_cx(), &error);
1232 return false;
1233
1234 }
1235 _ => {
1236 return false;
1237
1238 },
1239 }
1240 ;
1241 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
1242 Ok(ConversionResult::Success(value)) => value,
1243 Ok(ConversionResult::Failure(error)) => {
1244 throw_type_error(cx.raw_cx(), &error);
1245 return false;
1246
1247 }
1248 _ => {
1249 return false;
1250
1251 },
1252 }
1253 ;
1254 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
1255 Ok(ConversionResult::Success(value)) => value,
1256 Ok(ConversionResult::Failure(error)) => {
1257 throw_type_error(cx.raw_cx(), &error);
1258 return false;
1259
1260 }
1261 _ => {
1262 return false;
1263
1264 },
1265 }
1266 ;
1267 let result: () = this.BlendColor(arg0, arg1, arg2, arg3);
1268
1269 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1270 return true;
1271 })());
1272 result
1273}
1274
1275
1276static blendColor_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1277
1278pub(crate) fn init_blendColor_methodinfo<D: DomTypes>() {
1279 blendColor_methodinfo.set(JSJitInfo {
1280 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1281 method: Some(blendColor::<D>)
1282 },
1283 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1284 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1285 },
1286 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1287 _bitfield_align_1: [],
1288 _bitfield_1: __BindgenBitfieldUnit::new(
1289 new_jsjitinfo_bitfield_1!(
1290 JSJitInfo_OpType::Method as u8,
1291 JSJitInfo_AliasSet::AliasEverything as u8,
1292 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1293 false,
1294 false,
1295 false,
1296 false,
1297 false,
1298 false,
1299 0,
1300 ).to_ne_bytes()
1301 ),
1302});
1303}
1304unsafe extern "C" fn blendEquation<D: DomTypes>
1305(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1306 let mut result = false;
1307 wrap_panic(&mut || result = (|| {
1308 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1309 let this = &*(this as *const D::WebGLRenderingContext);
1310 let args = &*args;
1311 let argc = args.argc_;
1312
1313 if argc < 1 {
1314 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.blendEquation\".");
1315 return false;
1316 }
1317 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1318 Ok(ConversionResult::Success(value)) => value,
1319 Ok(ConversionResult::Failure(error)) => {
1320 throw_type_error(cx.raw_cx(), &error);
1321 return false;
1322
1323 }
1324 _ => {
1325 return false;
1326
1327 },
1328 }
1329 ;
1330 let result: () = this.BlendEquation(arg0);
1331
1332 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1333 return true;
1334 })());
1335 result
1336}
1337
1338
1339static blendEquation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1340
1341pub(crate) fn init_blendEquation_methodinfo<D: DomTypes>() {
1342 blendEquation_methodinfo.set(JSJitInfo {
1343 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1344 method: Some(blendEquation::<D>)
1345 },
1346 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1347 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1348 },
1349 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1350 _bitfield_align_1: [],
1351 _bitfield_1: __BindgenBitfieldUnit::new(
1352 new_jsjitinfo_bitfield_1!(
1353 JSJitInfo_OpType::Method as u8,
1354 JSJitInfo_AliasSet::AliasEverything as u8,
1355 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1356 false,
1357 false,
1358 false,
1359 false,
1360 false,
1361 false,
1362 0,
1363 ).to_ne_bytes()
1364 ),
1365});
1366}
1367unsafe extern "C" fn blendEquationSeparate<D: DomTypes>
1368(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1369 let mut result = false;
1370 wrap_panic(&mut || result = (|| {
1371 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1372 let this = &*(this as *const D::WebGLRenderingContext);
1373 let args = &*args;
1374 let argc = args.argc_;
1375
1376 if argc < 2 {
1377 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.blendEquationSeparate\".");
1378 return false;
1379 }
1380 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1381 Ok(ConversionResult::Success(value)) => value,
1382 Ok(ConversionResult::Failure(error)) => {
1383 throw_type_error(cx.raw_cx(), &error);
1384 return false;
1385
1386 }
1387 _ => {
1388 return false;
1389
1390 },
1391 }
1392 ;
1393 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1394 Ok(ConversionResult::Success(value)) => value,
1395 Ok(ConversionResult::Failure(error)) => {
1396 throw_type_error(cx.raw_cx(), &error);
1397 return false;
1398
1399 }
1400 _ => {
1401 return false;
1402
1403 },
1404 }
1405 ;
1406 let result: () = this.BlendEquationSeparate(arg0, arg1);
1407
1408 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1409 return true;
1410 })());
1411 result
1412}
1413
1414
1415static blendEquationSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1416
1417pub(crate) fn init_blendEquationSeparate_methodinfo<D: DomTypes>() {
1418 blendEquationSeparate_methodinfo.set(JSJitInfo {
1419 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1420 method: Some(blendEquationSeparate::<D>)
1421 },
1422 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1423 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1424 },
1425 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1426 _bitfield_align_1: [],
1427 _bitfield_1: __BindgenBitfieldUnit::new(
1428 new_jsjitinfo_bitfield_1!(
1429 JSJitInfo_OpType::Method as u8,
1430 JSJitInfo_AliasSet::AliasEverything as u8,
1431 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1432 false,
1433 false,
1434 false,
1435 false,
1436 false,
1437 false,
1438 0,
1439 ).to_ne_bytes()
1440 ),
1441});
1442}
1443unsafe extern "C" fn blendFunc<D: DomTypes>
1444(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1445 let mut result = false;
1446 wrap_panic(&mut || result = (|| {
1447 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1448 let this = &*(this as *const D::WebGLRenderingContext);
1449 let args = &*args;
1450 let argc = args.argc_;
1451
1452 if argc < 2 {
1453 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.blendFunc\".");
1454 return false;
1455 }
1456 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1457 Ok(ConversionResult::Success(value)) => value,
1458 Ok(ConversionResult::Failure(error)) => {
1459 throw_type_error(cx.raw_cx(), &error);
1460 return false;
1461
1462 }
1463 _ => {
1464 return false;
1465
1466 },
1467 }
1468 ;
1469 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1470 Ok(ConversionResult::Success(value)) => value,
1471 Ok(ConversionResult::Failure(error)) => {
1472 throw_type_error(cx.raw_cx(), &error);
1473 return false;
1474
1475 }
1476 _ => {
1477 return false;
1478
1479 },
1480 }
1481 ;
1482 let result: () = this.BlendFunc(arg0, arg1);
1483
1484 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1485 return true;
1486 })());
1487 result
1488}
1489
1490
1491static blendFunc_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1492
1493pub(crate) fn init_blendFunc_methodinfo<D: DomTypes>() {
1494 blendFunc_methodinfo.set(JSJitInfo {
1495 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1496 method: Some(blendFunc::<D>)
1497 },
1498 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1499 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1500 },
1501 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1502 _bitfield_align_1: [],
1503 _bitfield_1: __BindgenBitfieldUnit::new(
1504 new_jsjitinfo_bitfield_1!(
1505 JSJitInfo_OpType::Method as u8,
1506 JSJitInfo_AliasSet::AliasEverything as u8,
1507 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1508 false,
1509 false,
1510 false,
1511 false,
1512 false,
1513 false,
1514 0,
1515 ).to_ne_bytes()
1516 ),
1517});
1518}
1519unsafe extern "C" fn blendFuncSeparate<D: DomTypes>
1520(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1521 let mut result = false;
1522 wrap_panic(&mut || result = (|| {
1523 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1524 let this = &*(this as *const D::WebGLRenderingContext);
1525 let args = &*args;
1526 let argc = args.argc_;
1527
1528 if argc < 4 {
1529 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.blendFuncSeparate\".");
1530 return false;
1531 }
1532 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1533 Ok(ConversionResult::Success(value)) => value,
1534 Ok(ConversionResult::Failure(error)) => {
1535 throw_type_error(cx.raw_cx(), &error);
1536 return false;
1537
1538 }
1539 _ => {
1540 return false;
1541
1542 },
1543 }
1544 ;
1545 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
1546 Ok(ConversionResult::Success(value)) => value,
1547 Ok(ConversionResult::Failure(error)) => {
1548 throw_type_error(cx.raw_cx(), &error);
1549 return false;
1550
1551 }
1552 _ => {
1553 return false;
1554
1555 },
1556 }
1557 ;
1558 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
1559 Ok(ConversionResult::Success(value)) => value,
1560 Ok(ConversionResult::Failure(error)) => {
1561 throw_type_error(cx.raw_cx(), &error);
1562 return false;
1563
1564 }
1565 _ => {
1566 return false;
1567
1568 },
1569 }
1570 ;
1571 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
1572 Ok(ConversionResult::Success(value)) => value,
1573 Ok(ConversionResult::Failure(error)) => {
1574 throw_type_error(cx.raw_cx(), &error);
1575 return false;
1576
1577 }
1578 _ => {
1579 return false;
1580
1581 },
1582 }
1583 ;
1584 let result: () = this.BlendFuncSeparate(arg0, arg1, arg2, arg3);
1585
1586 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1587 return true;
1588 })());
1589 result
1590}
1591
1592
1593static blendFuncSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1594
1595pub(crate) fn init_blendFuncSeparate_methodinfo<D: DomTypes>() {
1596 blendFuncSeparate_methodinfo.set(JSJitInfo {
1597 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1598 method: Some(blendFuncSeparate::<D>)
1599 },
1600 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1601 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1602 },
1603 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1604 _bitfield_align_1: [],
1605 _bitfield_1: __BindgenBitfieldUnit::new(
1606 new_jsjitinfo_bitfield_1!(
1607 JSJitInfo_OpType::Method as u8,
1608 JSJitInfo_AliasSet::AliasEverything as u8,
1609 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1610 false,
1611 false,
1612 false,
1613 false,
1614 false,
1615 false,
1616 0,
1617 ).to_ne_bytes()
1618 ),
1619});
1620}
1621unsafe extern "C" fn checkFramebufferStatus<D: DomTypes>
1622(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1623 let mut result = false;
1624 wrap_panic(&mut || result = (|| {
1625 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1626 let this = &*(this as *const D::WebGLRenderingContext);
1627 let args = &*args;
1628 let argc = args.argc_;
1629
1630 if argc < 1 {
1631 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.checkFramebufferStatus\".");
1632 return false;
1633 }
1634 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1635 Ok(ConversionResult::Success(value)) => value,
1636 Ok(ConversionResult::Failure(error)) => {
1637 throw_type_error(cx.raw_cx(), &error);
1638 return false;
1639
1640 }
1641 _ => {
1642 return false;
1643
1644 },
1645 }
1646 ;
1647 let result: u32 = this.CheckFramebufferStatus(arg0);
1648
1649 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1650 return true;
1651 })());
1652 result
1653}
1654
1655
1656static checkFramebufferStatus_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1657
1658pub(crate) fn init_checkFramebufferStatus_methodinfo<D: DomTypes>() {
1659 checkFramebufferStatus_methodinfo.set(JSJitInfo {
1660 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1661 method: Some(checkFramebufferStatus::<D>)
1662 },
1663 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1664 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1665 },
1666 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1667 _bitfield_align_1: [],
1668 _bitfield_1: __BindgenBitfieldUnit::new(
1669 new_jsjitinfo_bitfield_1!(
1670 JSJitInfo_OpType::Method as u8,
1671 JSJitInfo_AliasSet::AliasEverything as u8,
1672 JSValueType::JSVAL_TYPE_DOUBLE as u8,
1673 false,
1674 false,
1675 false,
1676 false,
1677 false,
1678 false,
1679 0,
1680 ).to_ne_bytes()
1681 ),
1682});
1683}
1684unsafe extern "C" fn clear<D: DomTypes>
1685(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1686 let mut result = false;
1687 wrap_panic(&mut || result = (|| {
1688 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1689 let this = &*(this as *const D::WebGLRenderingContext);
1690 let args = &*args;
1691 let argc = args.argc_;
1692
1693 if argc < 1 {
1694 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.clear\".");
1695 return false;
1696 }
1697 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1698 Ok(ConversionResult::Success(value)) => value,
1699 Ok(ConversionResult::Failure(error)) => {
1700 throw_type_error(cx.raw_cx(), &error);
1701 return false;
1702
1703 }
1704 _ => {
1705 return false;
1706
1707 },
1708 }
1709 ;
1710 let result: () = this.Clear(arg0);
1711
1712 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1713 return true;
1714 })());
1715 result
1716}
1717
1718
1719static clear_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1720
1721pub(crate) fn init_clear_methodinfo<D: DomTypes>() {
1722 clear_methodinfo.set(JSJitInfo {
1723 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1724 method: Some(clear::<D>)
1725 },
1726 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1727 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1728 },
1729 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1730 _bitfield_align_1: [],
1731 _bitfield_1: __BindgenBitfieldUnit::new(
1732 new_jsjitinfo_bitfield_1!(
1733 JSJitInfo_OpType::Method as u8,
1734 JSJitInfo_AliasSet::AliasEverything as u8,
1735 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1736 false,
1737 false,
1738 false,
1739 false,
1740 false,
1741 false,
1742 0,
1743 ).to_ne_bytes()
1744 ),
1745});
1746}
1747unsafe extern "C" fn clearColor<D: DomTypes>
1748(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1749 let mut result = false;
1750 wrap_panic(&mut || result = (|| {
1751 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1752 let this = &*(this as *const D::WebGLRenderingContext);
1753 let args = &*args;
1754 let argc = args.argc_;
1755
1756 if argc < 4 {
1757 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.clearColor\".");
1758 return false;
1759 }
1760 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1761 Ok(ConversionResult::Success(value)) => value,
1762 Ok(ConversionResult::Failure(error)) => {
1763 throw_type_error(cx.raw_cx(), &error);
1764 return false;
1765
1766 }
1767 _ => {
1768 return false;
1769
1770 },
1771 }
1772 ;
1773 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
1774 Ok(ConversionResult::Success(value)) => value,
1775 Ok(ConversionResult::Failure(error)) => {
1776 throw_type_error(cx.raw_cx(), &error);
1777 return false;
1778
1779 }
1780 _ => {
1781 return false;
1782
1783 },
1784 }
1785 ;
1786 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
1787 Ok(ConversionResult::Success(value)) => value,
1788 Ok(ConversionResult::Failure(error)) => {
1789 throw_type_error(cx.raw_cx(), &error);
1790 return false;
1791
1792 }
1793 _ => {
1794 return false;
1795
1796 },
1797 }
1798 ;
1799 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
1800 Ok(ConversionResult::Success(value)) => value,
1801 Ok(ConversionResult::Failure(error)) => {
1802 throw_type_error(cx.raw_cx(), &error);
1803 return false;
1804
1805 }
1806 _ => {
1807 return false;
1808
1809 },
1810 }
1811 ;
1812 let result: () = this.ClearColor(arg0, arg1, arg2, arg3);
1813
1814 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1815 return true;
1816 })());
1817 result
1818}
1819
1820
1821static clearColor_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1822
1823pub(crate) fn init_clearColor_methodinfo<D: DomTypes>() {
1824 clearColor_methodinfo.set(JSJitInfo {
1825 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1826 method: Some(clearColor::<D>)
1827 },
1828 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1829 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1830 },
1831 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1832 _bitfield_align_1: [],
1833 _bitfield_1: __BindgenBitfieldUnit::new(
1834 new_jsjitinfo_bitfield_1!(
1835 JSJitInfo_OpType::Method as u8,
1836 JSJitInfo_AliasSet::AliasEverything as u8,
1837 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1838 false,
1839 false,
1840 false,
1841 false,
1842 false,
1843 false,
1844 0,
1845 ).to_ne_bytes()
1846 ),
1847});
1848}
1849unsafe extern "C" fn clearDepth<D: DomTypes>
1850(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1851 let mut result = false;
1852 wrap_panic(&mut || result = (|| {
1853 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1854 let this = &*(this as *const D::WebGLRenderingContext);
1855 let args = &*args;
1856 let argc = args.argc_;
1857
1858 if argc < 1 {
1859 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.clearDepth\".");
1860 return false;
1861 }
1862 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1863 Ok(ConversionResult::Success(value)) => value,
1864 Ok(ConversionResult::Failure(error)) => {
1865 throw_type_error(cx.raw_cx(), &error);
1866 return false;
1867
1868 }
1869 _ => {
1870 return false;
1871
1872 },
1873 }
1874 ;
1875 let result: () = this.ClearDepth(arg0);
1876
1877 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1878 return true;
1879 })());
1880 result
1881}
1882
1883
1884static clearDepth_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1885
1886pub(crate) fn init_clearDepth_methodinfo<D: DomTypes>() {
1887 clearDepth_methodinfo.set(JSJitInfo {
1888 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1889 method: Some(clearDepth::<D>)
1890 },
1891 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1892 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1893 },
1894 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1895 _bitfield_align_1: [],
1896 _bitfield_1: __BindgenBitfieldUnit::new(
1897 new_jsjitinfo_bitfield_1!(
1898 JSJitInfo_OpType::Method as u8,
1899 JSJitInfo_AliasSet::AliasEverything as u8,
1900 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1901 false,
1902 false,
1903 false,
1904 false,
1905 false,
1906 false,
1907 0,
1908 ).to_ne_bytes()
1909 ),
1910});
1911}
1912unsafe extern "C" fn clearStencil<D: DomTypes>
1913(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1914 let mut result = false;
1915 wrap_panic(&mut || result = (|| {
1916 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1917 let this = &*(this as *const D::WebGLRenderingContext);
1918 let args = &*args;
1919 let argc = args.argc_;
1920
1921 if argc < 1 {
1922 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.clearStencil\".");
1923 return false;
1924 }
1925 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1926 Ok(ConversionResult::Success(value)) => value,
1927 Ok(ConversionResult::Failure(error)) => {
1928 throw_type_error(cx.raw_cx(), &error);
1929 return false;
1930
1931 }
1932 _ => {
1933 return false;
1934
1935 },
1936 }
1937 ;
1938 let result: () = this.ClearStencil(arg0);
1939
1940 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1941 return true;
1942 })());
1943 result
1944}
1945
1946
1947static clearStencil_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1948
1949pub(crate) fn init_clearStencil_methodinfo<D: DomTypes>() {
1950 clearStencil_methodinfo.set(JSJitInfo {
1951 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1952 method: Some(clearStencil::<D>)
1953 },
1954 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1955 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
1956 },
1957 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
1958 _bitfield_align_1: [],
1959 _bitfield_1: __BindgenBitfieldUnit::new(
1960 new_jsjitinfo_bitfield_1!(
1961 JSJitInfo_OpType::Method as u8,
1962 JSJitInfo_AliasSet::AliasEverything as u8,
1963 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1964 false,
1965 false,
1966 false,
1967 false,
1968 false,
1969 false,
1970 0,
1971 ).to_ne_bytes()
1972 ),
1973});
1974}
1975unsafe extern "C" fn colorMask<D: DomTypes>
1976(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
1977 let mut result = false;
1978 wrap_panic(&mut || result = (|| {
1979 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1980 let this = &*(this as *const D::WebGLRenderingContext);
1981 let args = &*args;
1982 let argc = args.argc_;
1983
1984 if argc < 4 {
1985 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.colorMask\".");
1986 return false;
1987 }
1988 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1989 Ok(ConversionResult::Success(value)) => value,
1990 Ok(ConversionResult::Failure(error)) => {
1991 throw_type_error(cx.raw_cx(), &error);
1992 return false;
1993
1994 }
1995 _ => {
1996 return false;
1997
1998 },
1999 }
2000 ;
2001 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
2002 Ok(ConversionResult::Success(value)) => value,
2003 Ok(ConversionResult::Failure(error)) => {
2004 throw_type_error(cx.raw_cx(), &error);
2005 return false;
2006
2007 }
2008 _ => {
2009 return false;
2010
2011 },
2012 }
2013 ;
2014 let arg2: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
2015 Ok(ConversionResult::Success(value)) => value,
2016 Ok(ConversionResult::Failure(error)) => {
2017 throw_type_error(cx.raw_cx(), &error);
2018 return false;
2019
2020 }
2021 _ => {
2022 return false;
2023
2024 },
2025 }
2026 ;
2027 let arg3: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
2028 Ok(ConversionResult::Success(value)) => value,
2029 Ok(ConversionResult::Failure(error)) => {
2030 throw_type_error(cx.raw_cx(), &error);
2031 return false;
2032
2033 }
2034 _ => {
2035 return false;
2036
2037 },
2038 }
2039 ;
2040 let result: () = this.ColorMask(arg0, arg1, arg2, arg3);
2041
2042 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2043 return true;
2044 })());
2045 result
2046}
2047
2048
2049static colorMask_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2050
2051pub(crate) fn init_colorMask_methodinfo<D: DomTypes>() {
2052 colorMask_methodinfo.set(JSJitInfo {
2053 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2054 method: Some(colorMask::<D>)
2055 },
2056 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2057 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2058 },
2059 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2060 _bitfield_align_1: [],
2061 _bitfield_1: __BindgenBitfieldUnit::new(
2062 new_jsjitinfo_bitfield_1!(
2063 JSJitInfo_OpType::Method as u8,
2064 JSJitInfo_AliasSet::AliasEverything as u8,
2065 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2066 false,
2067 false,
2068 false,
2069 false,
2070 false,
2071 false,
2072 0,
2073 ).to_ne_bytes()
2074 ),
2075});
2076}
2077unsafe extern "C" fn compileShader<D: DomTypes>
2078(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2079 let mut result = false;
2080 wrap_panic(&mut || result = (|| {
2081 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2082 let this = &*(this as *const D::WebGLRenderingContext);
2083 let args = &*args;
2084 let argc = args.argc_;
2085
2086 if argc < 1 {
2087 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.compileShader\".");
2088 return false;
2089 }
2090 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2091 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2092 Ok(val) => val,
2093 Err(()) => {
2094 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
2095 return false;
2096
2097 }
2098 }
2099
2100 } else {
2101 throw_type_error(cx.raw_cx(), "Value is not an object.");
2102 return false;
2103
2104 };
2105 let result: () = this.CompileShader(&arg0);
2106
2107 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2108 return true;
2109 })());
2110 result
2111}
2112
2113
2114static compileShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2115
2116pub(crate) fn init_compileShader_methodinfo<D: DomTypes>() {
2117 compileShader_methodinfo.set(JSJitInfo {
2118 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2119 method: Some(compileShader::<D>)
2120 },
2121 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2122 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2123 },
2124 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2125 _bitfield_align_1: [],
2126 _bitfield_1: __BindgenBitfieldUnit::new(
2127 new_jsjitinfo_bitfield_1!(
2128 JSJitInfo_OpType::Method as u8,
2129 JSJitInfo_AliasSet::AliasEverything as u8,
2130 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2131 false,
2132 false,
2133 false,
2134 false,
2135 false,
2136 false,
2137 0,
2138 ).to_ne_bytes()
2139 ),
2140});
2141}
2142unsafe extern "C" fn copyTexImage2D<D: DomTypes>
2143(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2144 let mut result = false;
2145 wrap_panic(&mut || result = (|| {
2146 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2147 let this = &*(this as *const D::WebGLRenderingContext);
2148 let args = &*args;
2149 let argc = args.argc_;
2150
2151 if argc < 8 {
2152 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.copyTexImage2D\".");
2153 return false;
2154 }
2155 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2156 Ok(ConversionResult::Success(value)) => value,
2157 Ok(ConversionResult::Failure(error)) => {
2158 throw_type_error(cx.raw_cx(), &error);
2159 return false;
2160
2161 }
2162 _ => {
2163 return false;
2164
2165 },
2166 }
2167 ;
2168 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
2169 Ok(ConversionResult::Success(value)) => value,
2170 Ok(ConversionResult::Failure(error)) => {
2171 throw_type_error(cx.raw_cx(), &error);
2172 return false;
2173
2174 }
2175 _ => {
2176 return false;
2177
2178 },
2179 }
2180 ;
2181 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
2182 Ok(ConversionResult::Success(value)) => value,
2183 Ok(ConversionResult::Failure(error)) => {
2184 throw_type_error(cx.raw_cx(), &error);
2185 return false;
2186
2187 }
2188 _ => {
2189 return false;
2190
2191 },
2192 }
2193 ;
2194 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2195 Ok(ConversionResult::Success(value)) => value,
2196 Ok(ConversionResult::Failure(error)) => {
2197 throw_type_error(cx.raw_cx(), &error);
2198 return false;
2199
2200 }
2201 _ => {
2202 return false;
2203
2204 },
2205 }
2206 ;
2207 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
2208 Ok(ConversionResult::Success(value)) => value,
2209 Ok(ConversionResult::Failure(error)) => {
2210 throw_type_error(cx.raw_cx(), &error);
2211 return false;
2212
2213 }
2214 _ => {
2215 return false;
2216
2217 },
2218 }
2219 ;
2220 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
2221 Ok(ConversionResult::Success(value)) => value,
2222 Ok(ConversionResult::Failure(error)) => {
2223 throw_type_error(cx.raw_cx(), &error);
2224 return false;
2225
2226 }
2227 _ => {
2228 return false;
2229
2230 },
2231 }
2232 ;
2233 let arg6: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
2234 Ok(ConversionResult::Success(value)) => value,
2235 Ok(ConversionResult::Failure(error)) => {
2236 throw_type_error(cx.raw_cx(), &error);
2237 return false;
2238
2239 }
2240 _ => {
2241 return false;
2242
2243 },
2244 }
2245 ;
2246 let arg7: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
2247 Ok(ConversionResult::Success(value)) => value,
2248 Ok(ConversionResult::Failure(error)) => {
2249 throw_type_error(cx.raw_cx(), &error);
2250 return false;
2251
2252 }
2253 _ => {
2254 return false;
2255
2256 },
2257 }
2258 ;
2259 let result: () = this.CopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2260
2261 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2262 return true;
2263 })());
2264 result
2265}
2266
2267
2268static copyTexImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2269
2270pub(crate) fn init_copyTexImage2D_methodinfo<D: DomTypes>() {
2271 copyTexImage2D_methodinfo.set(JSJitInfo {
2272 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2273 method: Some(copyTexImage2D::<D>)
2274 },
2275 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2276 protoID: PrototypeList::ID::WebGLRenderingContext 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 copyTexSubImage2D<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::WebGLRenderingContext);
2302 let args = &*args;
2303 let argc = args.argc_;
2304
2305 if argc < 8 {
2306 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.copyTexSubImage2D\".");
2307 return false;
2308 }
2309 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2310 Ok(ConversionResult::Success(value)) => value,
2311 Ok(ConversionResult::Failure(error)) => {
2312 throw_type_error(cx.raw_cx(), &error);
2313 return false;
2314
2315 }
2316 _ => {
2317 return false;
2318
2319 },
2320 }
2321 ;
2322 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
2323 Ok(ConversionResult::Success(value)) => value,
2324 Ok(ConversionResult::Failure(error)) => {
2325 throw_type_error(cx.raw_cx(), &error);
2326 return false;
2327
2328 }
2329 _ => {
2330 return false;
2331
2332 },
2333 }
2334 ;
2335 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
2336 Ok(ConversionResult::Success(value)) => value,
2337 Ok(ConversionResult::Failure(error)) => {
2338 throw_type_error(cx.raw_cx(), &error);
2339 return false;
2340
2341 }
2342 _ => {
2343 return false;
2344
2345 },
2346 }
2347 ;
2348 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
2349 Ok(ConversionResult::Success(value)) => value,
2350 Ok(ConversionResult::Failure(error)) => {
2351 throw_type_error(cx.raw_cx(), &error);
2352 return false;
2353
2354 }
2355 _ => {
2356 return false;
2357
2358 },
2359 }
2360 ;
2361 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
2362 Ok(ConversionResult::Success(value)) => value,
2363 Ok(ConversionResult::Failure(error)) => {
2364 throw_type_error(cx.raw_cx(), &error);
2365 return false;
2366
2367 }
2368 _ => {
2369 return false;
2370
2371 },
2372 }
2373 ;
2374 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
2375 Ok(ConversionResult::Success(value)) => value,
2376 Ok(ConversionResult::Failure(error)) => {
2377 throw_type_error(cx.raw_cx(), &error);
2378 return false;
2379
2380 }
2381 _ => {
2382 return false;
2383
2384 },
2385 }
2386 ;
2387 let arg6: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
2388 Ok(ConversionResult::Success(value)) => value,
2389 Ok(ConversionResult::Failure(error)) => {
2390 throw_type_error(cx.raw_cx(), &error);
2391 return false;
2392
2393 }
2394 _ => {
2395 return false;
2396
2397 },
2398 }
2399 ;
2400 let arg7: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
2401 Ok(ConversionResult::Success(value)) => value,
2402 Ok(ConversionResult::Failure(error)) => {
2403 throw_type_error(cx.raw_cx(), &error);
2404 return false;
2405
2406 }
2407 _ => {
2408 return false;
2409
2410 },
2411 }
2412 ;
2413 let result: () = this.CopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2414
2415 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2416 return true;
2417 })());
2418 result
2419}
2420
2421
2422static copyTexSubImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2423
2424pub(crate) fn init_copyTexSubImage2D_methodinfo<D: DomTypes>() {
2425 copyTexSubImage2D_methodinfo.set(JSJitInfo {
2426 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2427 method: Some(copyTexSubImage2D::<D>)
2428 },
2429 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2430 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2431 },
2432 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2433 _bitfield_align_1: [],
2434 _bitfield_1: __BindgenBitfieldUnit::new(
2435 new_jsjitinfo_bitfield_1!(
2436 JSJitInfo_OpType::Method as u8,
2437 JSJitInfo_AliasSet::AliasEverything as u8,
2438 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2439 false,
2440 false,
2441 false,
2442 false,
2443 false,
2444 false,
2445 0,
2446 ).to_ne_bytes()
2447 ),
2448});
2449}
2450unsafe extern "C" fn createBuffer<D: DomTypes>
2451(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2452 let mut result = false;
2453 wrap_panic(&mut || result = (|| {
2454 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2455 let this = &*(this as *const D::WebGLRenderingContext);
2456 let args = &*args;
2457 let argc = args.argc_;
2458 let result: Option<DomRoot<D::WebGLBuffer>> = this.CreateBuffer();
2459
2460 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2461 return true;
2462 })());
2463 result
2464}
2465
2466
2467static createBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2468
2469pub(crate) fn init_createBuffer_methodinfo<D: DomTypes>() {
2470 createBuffer_methodinfo.set(JSJitInfo {
2471 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2472 method: Some(createBuffer::<D>)
2473 },
2474 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2475 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2476 },
2477 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2478 _bitfield_align_1: [],
2479 _bitfield_1: __BindgenBitfieldUnit::new(
2480 new_jsjitinfo_bitfield_1!(
2481 JSJitInfo_OpType::Method as u8,
2482 JSJitInfo_AliasSet::AliasEverything as u8,
2483 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2484 true,
2485 false,
2486 false,
2487 false,
2488 false,
2489 false,
2490 0,
2491 ).to_ne_bytes()
2492 ),
2493});
2494}
2495unsafe extern "C" fn createFramebuffer<D: DomTypes>
2496(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2497 let mut result = false;
2498 wrap_panic(&mut || result = (|| {
2499 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2500 let this = &*(this as *const D::WebGLRenderingContext);
2501 let args = &*args;
2502 let argc = args.argc_;
2503 let result: Option<DomRoot<D::WebGLFramebuffer>> = this.CreateFramebuffer();
2504
2505 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2506 return true;
2507 })());
2508 result
2509}
2510
2511
2512static createFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2513
2514pub(crate) fn init_createFramebuffer_methodinfo<D: DomTypes>() {
2515 createFramebuffer_methodinfo.set(JSJitInfo {
2516 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2517 method: Some(createFramebuffer::<D>)
2518 },
2519 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2520 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2521 },
2522 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2523 _bitfield_align_1: [],
2524 _bitfield_1: __BindgenBitfieldUnit::new(
2525 new_jsjitinfo_bitfield_1!(
2526 JSJitInfo_OpType::Method as u8,
2527 JSJitInfo_AliasSet::AliasEverything as u8,
2528 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2529 true,
2530 false,
2531 false,
2532 false,
2533 false,
2534 false,
2535 0,
2536 ).to_ne_bytes()
2537 ),
2538});
2539}
2540unsafe extern "C" fn createProgram<D: DomTypes>
2541(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2542 let mut result = false;
2543 wrap_panic(&mut || result = (|| {
2544 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2545 let this = &*(this as *const D::WebGLRenderingContext);
2546 let args = &*args;
2547 let argc = args.argc_;
2548 let result: Option<DomRoot<D::WebGLProgram>> = this.CreateProgram();
2549
2550 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2551 return true;
2552 })());
2553 result
2554}
2555
2556
2557static createProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2558
2559pub(crate) fn init_createProgram_methodinfo<D: DomTypes>() {
2560 createProgram_methodinfo.set(JSJitInfo {
2561 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2562 method: Some(createProgram::<D>)
2563 },
2564 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2565 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2566 },
2567 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2568 _bitfield_align_1: [],
2569 _bitfield_1: __BindgenBitfieldUnit::new(
2570 new_jsjitinfo_bitfield_1!(
2571 JSJitInfo_OpType::Method as u8,
2572 JSJitInfo_AliasSet::AliasEverything as u8,
2573 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2574 true,
2575 false,
2576 false,
2577 false,
2578 false,
2579 false,
2580 0,
2581 ).to_ne_bytes()
2582 ),
2583});
2584}
2585unsafe extern "C" fn createRenderbuffer<D: DomTypes>
2586(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2587 let mut result = false;
2588 wrap_panic(&mut || result = (|| {
2589 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2590 let this = &*(this as *const D::WebGLRenderingContext);
2591 let args = &*args;
2592 let argc = args.argc_;
2593 let result: Option<DomRoot<D::WebGLRenderbuffer>> = this.CreateRenderbuffer();
2594
2595 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2596 return true;
2597 })());
2598 result
2599}
2600
2601
2602static createRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2603
2604pub(crate) fn init_createRenderbuffer_methodinfo<D: DomTypes>() {
2605 createRenderbuffer_methodinfo.set(JSJitInfo {
2606 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2607 method: Some(createRenderbuffer::<D>)
2608 },
2609 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2610 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2611 },
2612 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2613 _bitfield_align_1: [],
2614 _bitfield_1: __BindgenBitfieldUnit::new(
2615 new_jsjitinfo_bitfield_1!(
2616 JSJitInfo_OpType::Method as u8,
2617 JSJitInfo_AliasSet::AliasEverything as u8,
2618 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2619 true,
2620 false,
2621 false,
2622 false,
2623 false,
2624 false,
2625 0,
2626 ).to_ne_bytes()
2627 ),
2628});
2629}
2630unsafe extern "C" fn createShader<D: DomTypes>
2631(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2632 let mut result = false;
2633 wrap_panic(&mut || result = (|| {
2634 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2635 let this = &*(this as *const D::WebGLRenderingContext);
2636 let args = &*args;
2637 let argc = args.argc_;
2638
2639 if argc < 1 {
2640 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.createShader\".");
2641 return false;
2642 }
2643 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2644 Ok(ConversionResult::Success(value)) => value,
2645 Ok(ConversionResult::Failure(error)) => {
2646 throw_type_error(cx.raw_cx(), &error);
2647 return false;
2648
2649 }
2650 _ => {
2651 return false;
2652
2653 },
2654 }
2655 ;
2656 let result: Option<DomRoot<D::WebGLShader>> = this.CreateShader(arg0);
2657
2658 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2659 return true;
2660 })());
2661 result
2662}
2663
2664
2665static createShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2666
2667pub(crate) fn init_createShader_methodinfo<D: DomTypes>() {
2668 createShader_methodinfo.set(JSJitInfo {
2669 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2670 method: Some(createShader::<D>)
2671 },
2672 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2673 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2674 },
2675 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2676 _bitfield_align_1: [],
2677 _bitfield_1: __BindgenBitfieldUnit::new(
2678 new_jsjitinfo_bitfield_1!(
2679 JSJitInfo_OpType::Method as u8,
2680 JSJitInfo_AliasSet::AliasEverything as u8,
2681 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2682 false,
2683 false,
2684 false,
2685 false,
2686 false,
2687 false,
2688 0,
2689 ).to_ne_bytes()
2690 ),
2691});
2692}
2693unsafe extern "C" fn createTexture<D: DomTypes>
2694(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2695 let mut result = false;
2696 wrap_panic(&mut || result = (|| {
2697 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2698 let this = &*(this as *const D::WebGLRenderingContext);
2699 let args = &*args;
2700 let argc = args.argc_;
2701 let result: Option<DomRoot<D::WebGLTexture>> = this.CreateTexture();
2702
2703 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2704 return true;
2705 })());
2706 result
2707}
2708
2709
2710static createTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2711
2712pub(crate) fn init_createTexture_methodinfo<D: DomTypes>() {
2713 createTexture_methodinfo.set(JSJitInfo {
2714 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2715 method: Some(createTexture::<D>)
2716 },
2717 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2718 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2719 },
2720 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2721 _bitfield_align_1: [],
2722 _bitfield_1: __BindgenBitfieldUnit::new(
2723 new_jsjitinfo_bitfield_1!(
2724 JSJitInfo_OpType::Method as u8,
2725 JSJitInfo_AliasSet::AliasEverything as u8,
2726 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
2727 true,
2728 false,
2729 false,
2730 false,
2731 false,
2732 false,
2733 0,
2734 ).to_ne_bytes()
2735 ),
2736});
2737}
2738unsafe extern "C" fn cullFace<D: DomTypes>
2739(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2740 let mut result = false;
2741 wrap_panic(&mut || result = (|| {
2742 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2743 let this = &*(this as *const D::WebGLRenderingContext);
2744 let args = &*args;
2745 let argc = args.argc_;
2746
2747 if argc < 1 {
2748 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.cullFace\".");
2749 return false;
2750 }
2751 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2752 Ok(ConversionResult::Success(value)) => value,
2753 Ok(ConversionResult::Failure(error)) => {
2754 throw_type_error(cx.raw_cx(), &error);
2755 return false;
2756
2757 }
2758 _ => {
2759 return false;
2760
2761 },
2762 }
2763 ;
2764 let result: () = this.CullFace(arg0);
2765
2766 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2767 return true;
2768 })());
2769 result
2770}
2771
2772
2773static cullFace_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2774
2775pub(crate) fn init_cullFace_methodinfo<D: DomTypes>() {
2776 cullFace_methodinfo.set(JSJitInfo {
2777 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2778 method: Some(cullFace::<D>)
2779 },
2780 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2781 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2782 },
2783 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2784 _bitfield_align_1: [],
2785 _bitfield_1: __BindgenBitfieldUnit::new(
2786 new_jsjitinfo_bitfield_1!(
2787 JSJitInfo_OpType::Method as u8,
2788 JSJitInfo_AliasSet::AliasEverything as u8,
2789 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2790 false,
2791 false,
2792 false,
2793 false,
2794 false,
2795 false,
2796 0,
2797 ).to_ne_bytes()
2798 ),
2799});
2800}
2801unsafe extern "C" fn deleteBuffer<D: DomTypes>
2802(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2803 let mut result = false;
2804 wrap_panic(&mut || result = (|| {
2805 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2806 let this = &*(this as *const D::WebGLRenderingContext);
2807 let args = &*args;
2808 let argc = args.argc_;
2809
2810 if argc < 1 {
2811 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.deleteBuffer\".");
2812 return false;
2813 }
2814 let arg0: Option<DomRoot<D::WebGLBuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2815 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2816 Ok(val) => val,
2817 Err(()) => {
2818 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLBuffer.");
2819 return false;
2820
2821 }
2822 }
2823 )
2824 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2825 None
2826 } else {
2827 throw_type_error(cx.raw_cx(), "Value is not an object.");
2828 return false;
2829
2830 };
2831 let result: () = this.DeleteBuffer(arg0.as_deref());
2832
2833 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2834 return true;
2835 })());
2836 result
2837}
2838
2839
2840static deleteBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2841
2842pub(crate) fn init_deleteBuffer_methodinfo<D: DomTypes>() {
2843 deleteBuffer_methodinfo.set(JSJitInfo {
2844 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2845 method: Some(deleteBuffer::<D>)
2846 },
2847 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2848 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2849 },
2850 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2851 _bitfield_align_1: [],
2852 _bitfield_1: __BindgenBitfieldUnit::new(
2853 new_jsjitinfo_bitfield_1!(
2854 JSJitInfo_OpType::Method as u8,
2855 JSJitInfo_AliasSet::AliasEverything as u8,
2856 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2857 false,
2858 false,
2859 false,
2860 false,
2861 false,
2862 false,
2863 0,
2864 ).to_ne_bytes()
2865 ),
2866});
2867}
2868unsafe extern "C" fn deleteFramebuffer<D: DomTypes>
2869(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2870 let mut result = false;
2871 wrap_panic(&mut || result = (|| {
2872 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2873 let this = &*(this as *const D::WebGLRenderingContext);
2874 let args = &*args;
2875 let argc = args.argc_;
2876
2877 if argc < 1 {
2878 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.deleteFramebuffer\".");
2879 return false;
2880 }
2881 let arg0: Option<DomRoot<D::WebGLFramebuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2882 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2883 Ok(val) => val,
2884 Err(()) => {
2885 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLFramebuffer.");
2886 return false;
2887
2888 }
2889 }
2890 )
2891 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2892 None
2893 } else {
2894 throw_type_error(cx.raw_cx(), "Value is not an object.");
2895 return false;
2896
2897 };
2898 let result: () = this.DeleteFramebuffer(arg0.as_deref());
2899
2900 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2901 return true;
2902 })());
2903 result
2904}
2905
2906
2907static deleteFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2908
2909pub(crate) fn init_deleteFramebuffer_methodinfo<D: DomTypes>() {
2910 deleteFramebuffer_methodinfo.set(JSJitInfo {
2911 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2912 method: Some(deleteFramebuffer::<D>)
2913 },
2914 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2915 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2916 },
2917 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2918 _bitfield_align_1: [],
2919 _bitfield_1: __BindgenBitfieldUnit::new(
2920 new_jsjitinfo_bitfield_1!(
2921 JSJitInfo_OpType::Method as u8,
2922 JSJitInfo_AliasSet::AliasEverything as u8,
2923 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2924 false,
2925 false,
2926 false,
2927 false,
2928 false,
2929 false,
2930 0,
2931 ).to_ne_bytes()
2932 ),
2933});
2934}
2935unsafe extern "C" fn deleteProgram<D: DomTypes>
2936(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
2937 let mut result = false;
2938 wrap_panic(&mut || result = (|| {
2939 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2940 let this = &*(this as *const D::WebGLRenderingContext);
2941 let args = &*args;
2942 let argc = args.argc_;
2943
2944 if argc < 1 {
2945 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.deleteProgram\".");
2946 return false;
2947 }
2948 let arg0: Option<DomRoot<D::WebGLProgram>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
2949 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
2950 Ok(val) => val,
2951 Err(()) => {
2952 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
2953 return false;
2954
2955 }
2956 }
2957 )
2958 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
2959 None
2960 } else {
2961 throw_type_error(cx.raw_cx(), "Value is not an object.");
2962 return false;
2963
2964 };
2965 let result: () = this.DeleteProgram(arg0.as_deref());
2966
2967 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2968 return true;
2969 })());
2970 result
2971}
2972
2973
2974static deleteProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2975
2976pub(crate) fn init_deleteProgram_methodinfo<D: DomTypes>() {
2977 deleteProgram_methodinfo.set(JSJitInfo {
2978 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2979 method: Some(deleteProgram::<D>)
2980 },
2981 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2982 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
2983 },
2984 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2985 _bitfield_align_1: [],
2986 _bitfield_1: __BindgenBitfieldUnit::new(
2987 new_jsjitinfo_bitfield_1!(
2988 JSJitInfo_OpType::Method as u8,
2989 JSJitInfo_AliasSet::AliasEverything as u8,
2990 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2991 false,
2992 false,
2993 false,
2994 false,
2995 false,
2996 false,
2997 0,
2998 ).to_ne_bytes()
2999 ),
3000});
3001}
3002unsafe extern "C" fn deleteRenderbuffer<D: DomTypes>
3003(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3004 let mut result = false;
3005 wrap_panic(&mut || result = (|| {
3006 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3007 let this = &*(this as *const D::WebGLRenderingContext);
3008 let args = &*args;
3009 let argc = args.argc_;
3010
3011 if argc < 1 {
3012 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.deleteRenderbuffer\".");
3013 return false;
3014 }
3015 let arg0: Option<DomRoot<D::WebGLRenderbuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
3016 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
3017 Ok(val) => val,
3018 Err(()) => {
3019 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLRenderbuffer.");
3020 return false;
3021
3022 }
3023 }
3024 )
3025 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
3026 None
3027 } else {
3028 throw_type_error(cx.raw_cx(), "Value is not an object.");
3029 return false;
3030
3031 };
3032 let result: () = this.DeleteRenderbuffer(arg0.as_deref());
3033
3034 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3035 return true;
3036 })());
3037 result
3038}
3039
3040
3041static deleteRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3042
3043pub(crate) fn init_deleteRenderbuffer_methodinfo<D: DomTypes>() {
3044 deleteRenderbuffer_methodinfo.set(JSJitInfo {
3045 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3046 method: Some(deleteRenderbuffer::<D>)
3047 },
3048 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3049 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3050 },
3051 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3052 _bitfield_align_1: [],
3053 _bitfield_1: __BindgenBitfieldUnit::new(
3054 new_jsjitinfo_bitfield_1!(
3055 JSJitInfo_OpType::Method as u8,
3056 JSJitInfo_AliasSet::AliasEverything as u8,
3057 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3058 false,
3059 false,
3060 false,
3061 false,
3062 false,
3063 false,
3064 0,
3065 ).to_ne_bytes()
3066 ),
3067});
3068}
3069unsafe extern "C" fn deleteShader<D: DomTypes>
3070(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3071 let mut result = false;
3072 wrap_panic(&mut || result = (|| {
3073 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3074 let this = &*(this as *const D::WebGLRenderingContext);
3075 let args = &*args;
3076 let argc = args.argc_;
3077
3078 if argc < 1 {
3079 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.deleteShader\".");
3080 return false;
3081 }
3082 let arg0: Option<DomRoot<D::WebGLShader>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
3083 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
3084 Ok(val) => val,
3085 Err(()) => {
3086 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
3087 return false;
3088
3089 }
3090 }
3091 )
3092 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
3093 None
3094 } else {
3095 throw_type_error(cx.raw_cx(), "Value is not an object.");
3096 return false;
3097
3098 };
3099 let result: () = this.DeleteShader(arg0.as_deref());
3100
3101 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3102 return true;
3103 })());
3104 result
3105}
3106
3107
3108static deleteShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3109
3110pub(crate) fn init_deleteShader_methodinfo<D: DomTypes>() {
3111 deleteShader_methodinfo.set(JSJitInfo {
3112 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3113 method: Some(deleteShader::<D>)
3114 },
3115 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3116 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3117 },
3118 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3119 _bitfield_align_1: [],
3120 _bitfield_1: __BindgenBitfieldUnit::new(
3121 new_jsjitinfo_bitfield_1!(
3122 JSJitInfo_OpType::Method as u8,
3123 JSJitInfo_AliasSet::AliasEverything as u8,
3124 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3125 false,
3126 false,
3127 false,
3128 false,
3129 false,
3130 false,
3131 0,
3132 ).to_ne_bytes()
3133 ),
3134});
3135}
3136unsafe extern "C" fn deleteTexture<D: DomTypes>
3137(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3138 let mut result = false;
3139 wrap_panic(&mut || result = (|| {
3140 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3141 let this = &*(this as *const D::WebGLRenderingContext);
3142 let args = &*args;
3143 let argc = args.argc_;
3144
3145 if argc < 1 {
3146 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.deleteTexture\".");
3147 return false;
3148 }
3149 let arg0: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
3150 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
3151 Ok(val) => val,
3152 Err(()) => {
3153 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
3154 return false;
3155
3156 }
3157 }
3158 )
3159 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
3160 None
3161 } else {
3162 throw_type_error(cx.raw_cx(), "Value is not an object.");
3163 return false;
3164
3165 };
3166 let result: () = this.DeleteTexture(arg0.as_deref());
3167
3168 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3169 return true;
3170 })());
3171 result
3172}
3173
3174
3175static deleteTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3176
3177pub(crate) fn init_deleteTexture_methodinfo<D: DomTypes>() {
3178 deleteTexture_methodinfo.set(JSJitInfo {
3179 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3180 method: Some(deleteTexture::<D>)
3181 },
3182 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3183 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3184 },
3185 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3186 _bitfield_align_1: [],
3187 _bitfield_1: __BindgenBitfieldUnit::new(
3188 new_jsjitinfo_bitfield_1!(
3189 JSJitInfo_OpType::Method as u8,
3190 JSJitInfo_AliasSet::AliasEverything as u8,
3191 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3192 false,
3193 false,
3194 false,
3195 false,
3196 false,
3197 false,
3198 0,
3199 ).to_ne_bytes()
3200 ),
3201});
3202}
3203unsafe extern "C" fn depthFunc<D: DomTypes>
3204(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3205 let mut result = false;
3206 wrap_panic(&mut || result = (|| {
3207 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3208 let this = &*(this as *const D::WebGLRenderingContext);
3209 let args = &*args;
3210 let argc = args.argc_;
3211
3212 if argc < 1 {
3213 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.depthFunc\".");
3214 return false;
3215 }
3216 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3217 Ok(ConversionResult::Success(value)) => value,
3218 Ok(ConversionResult::Failure(error)) => {
3219 throw_type_error(cx.raw_cx(), &error);
3220 return false;
3221
3222 }
3223 _ => {
3224 return false;
3225
3226 },
3227 }
3228 ;
3229 let result: () = this.DepthFunc(arg0);
3230
3231 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3232 return true;
3233 })());
3234 result
3235}
3236
3237
3238static depthFunc_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3239
3240pub(crate) fn init_depthFunc_methodinfo<D: DomTypes>() {
3241 depthFunc_methodinfo.set(JSJitInfo {
3242 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3243 method: Some(depthFunc::<D>)
3244 },
3245 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3246 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3247 },
3248 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3249 _bitfield_align_1: [],
3250 _bitfield_1: __BindgenBitfieldUnit::new(
3251 new_jsjitinfo_bitfield_1!(
3252 JSJitInfo_OpType::Method as u8,
3253 JSJitInfo_AliasSet::AliasEverything as u8,
3254 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3255 false,
3256 false,
3257 false,
3258 false,
3259 false,
3260 false,
3261 0,
3262 ).to_ne_bytes()
3263 ),
3264});
3265}
3266unsafe extern "C" fn depthMask<D: DomTypes>
3267(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3268 let mut result = false;
3269 wrap_panic(&mut || result = (|| {
3270 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3271 let this = &*(this as *const D::WebGLRenderingContext);
3272 let args = &*args;
3273 let argc = args.argc_;
3274
3275 if argc < 1 {
3276 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.depthMask\".");
3277 return false;
3278 }
3279 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3280 Ok(ConversionResult::Success(value)) => value,
3281 Ok(ConversionResult::Failure(error)) => {
3282 throw_type_error(cx.raw_cx(), &error);
3283 return false;
3284
3285 }
3286 _ => {
3287 return false;
3288
3289 },
3290 }
3291 ;
3292 let result: () = this.DepthMask(arg0);
3293
3294 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3295 return true;
3296 })());
3297 result
3298}
3299
3300
3301static depthMask_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3302
3303pub(crate) fn init_depthMask_methodinfo<D: DomTypes>() {
3304 depthMask_methodinfo.set(JSJitInfo {
3305 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3306 method: Some(depthMask::<D>)
3307 },
3308 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3309 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3310 },
3311 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3312 _bitfield_align_1: [],
3313 _bitfield_1: __BindgenBitfieldUnit::new(
3314 new_jsjitinfo_bitfield_1!(
3315 JSJitInfo_OpType::Method as u8,
3316 JSJitInfo_AliasSet::AliasEverything as u8,
3317 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3318 false,
3319 false,
3320 false,
3321 false,
3322 false,
3323 false,
3324 0,
3325 ).to_ne_bytes()
3326 ),
3327});
3328}
3329unsafe extern "C" fn depthRange<D: DomTypes>
3330(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3331 let mut result = false;
3332 wrap_panic(&mut || result = (|| {
3333 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3334 let this = &*(this as *const D::WebGLRenderingContext);
3335 let args = &*args;
3336 let argc = args.argc_;
3337
3338 if argc < 2 {
3339 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.depthRange\".");
3340 return false;
3341 }
3342 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3343 Ok(ConversionResult::Success(value)) => value,
3344 Ok(ConversionResult::Failure(error)) => {
3345 throw_type_error(cx.raw_cx(), &error);
3346 return false;
3347
3348 }
3349 _ => {
3350 return false;
3351
3352 },
3353 }
3354 ;
3355 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
3356 Ok(ConversionResult::Success(value)) => value,
3357 Ok(ConversionResult::Failure(error)) => {
3358 throw_type_error(cx.raw_cx(), &error);
3359 return false;
3360
3361 }
3362 _ => {
3363 return false;
3364
3365 },
3366 }
3367 ;
3368 let result: () = this.DepthRange(arg0, arg1);
3369
3370 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3371 return true;
3372 })());
3373 result
3374}
3375
3376
3377static depthRange_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3378
3379pub(crate) fn init_depthRange_methodinfo<D: DomTypes>() {
3380 depthRange_methodinfo.set(JSJitInfo {
3381 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3382 method: Some(depthRange::<D>)
3383 },
3384 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3385 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3386 },
3387 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3388 _bitfield_align_1: [],
3389 _bitfield_1: __BindgenBitfieldUnit::new(
3390 new_jsjitinfo_bitfield_1!(
3391 JSJitInfo_OpType::Method as u8,
3392 JSJitInfo_AliasSet::AliasEverything as u8,
3393 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3394 false,
3395 false,
3396 false,
3397 false,
3398 false,
3399 false,
3400 0,
3401 ).to_ne_bytes()
3402 ),
3403});
3404}
3405unsafe extern "C" fn detachShader<D: DomTypes>
3406(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3407 let mut result = false;
3408 wrap_panic(&mut || result = (|| {
3409 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3410 let this = &*(this as *const D::WebGLRenderingContext);
3411 let args = &*args;
3412 let argc = args.argc_;
3413
3414 if argc < 2 {
3415 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.detachShader\".");
3416 return false;
3417 }
3418 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
3419 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
3420 Ok(val) => val,
3421 Err(()) => {
3422 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
3423 return false;
3424
3425 }
3426 }
3427
3428 } else {
3429 throw_type_error(cx.raw_cx(), "Value is not an object.");
3430 return false;
3431
3432 };
3433 let arg1: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(1)).get().is_object() {
3434 match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
3435 Ok(val) => val,
3436 Err(()) => {
3437 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
3438 return false;
3439
3440 }
3441 }
3442
3443 } else {
3444 throw_type_error(cx.raw_cx(), "Value is not an object.");
3445 return false;
3446
3447 };
3448 let result: () = this.DetachShader(&arg0, &arg1);
3449
3450 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3451 return true;
3452 })());
3453 result
3454}
3455
3456
3457static detachShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3458
3459pub(crate) fn init_detachShader_methodinfo<D: DomTypes>() {
3460 detachShader_methodinfo.set(JSJitInfo {
3461 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3462 method: Some(detachShader::<D>)
3463 },
3464 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3465 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3466 },
3467 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3468 _bitfield_align_1: [],
3469 _bitfield_1: __BindgenBitfieldUnit::new(
3470 new_jsjitinfo_bitfield_1!(
3471 JSJitInfo_OpType::Method as u8,
3472 JSJitInfo_AliasSet::AliasEverything as u8,
3473 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3474 false,
3475 false,
3476 false,
3477 false,
3478 false,
3479 false,
3480 0,
3481 ).to_ne_bytes()
3482 ),
3483});
3484}
3485unsafe extern "C" fn disable<D: DomTypes>
3486(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3487 let mut result = false;
3488 wrap_panic(&mut || result = (|| {
3489 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3490 let this = &*(this as *const D::WebGLRenderingContext);
3491 let args = &*args;
3492 let argc = args.argc_;
3493
3494 if argc < 1 {
3495 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.disable\".");
3496 return false;
3497 }
3498 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3499 Ok(ConversionResult::Success(value)) => value,
3500 Ok(ConversionResult::Failure(error)) => {
3501 throw_type_error(cx.raw_cx(), &error);
3502 return false;
3503
3504 }
3505 _ => {
3506 return false;
3507
3508 },
3509 }
3510 ;
3511 let result: () = this.Disable(arg0);
3512
3513 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3514 return true;
3515 })());
3516 result
3517}
3518
3519
3520static disable_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3521
3522pub(crate) fn init_disable_methodinfo<D: DomTypes>() {
3523 disable_methodinfo.set(JSJitInfo {
3524 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3525 method: Some(disable::<D>)
3526 },
3527 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3528 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3529 },
3530 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3531 _bitfield_align_1: [],
3532 _bitfield_1: __BindgenBitfieldUnit::new(
3533 new_jsjitinfo_bitfield_1!(
3534 JSJitInfo_OpType::Method as u8,
3535 JSJitInfo_AliasSet::AliasEverything as u8,
3536 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3537 false,
3538 false,
3539 false,
3540 false,
3541 false,
3542 false,
3543 0,
3544 ).to_ne_bytes()
3545 ),
3546});
3547}
3548unsafe extern "C" fn disableVertexAttribArray<D: DomTypes>
3549(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3550 let mut result = false;
3551 wrap_panic(&mut || result = (|| {
3552 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3553 let this = &*(this as *const D::WebGLRenderingContext);
3554 let args = &*args;
3555 let argc = args.argc_;
3556
3557 if argc < 1 {
3558 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.disableVertexAttribArray\".");
3559 return false;
3560 }
3561 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3562 Ok(ConversionResult::Success(value)) => value,
3563 Ok(ConversionResult::Failure(error)) => {
3564 throw_type_error(cx.raw_cx(), &error);
3565 return false;
3566
3567 }
3568 _ => {
3569 return false;
3570
3571 },
3572 }
3573 ;
3574 let result: () = this.DisableVertexAttribArray(arg0);
3575
3576 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3577 return true;
3578 })());
3579 result
3580}
3581
3582
3583static disableVertexAttribArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3584
3585pub(crate) fn init_disableVertexAttribArray_methodinfo<D: DomTypes>() {
3586 disableVertexAttribArray_methodinfo.set(JSJitInfo {
3587 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3588 method: Some(disableVertexAttribArray::<D>)
3589 },
3590 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3591 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3592 },
3593 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3594 _bitfield_align_1: [],
3595 _bitfield_1: __BindgenBitfieldUnit::new(
3596 new_jsjitinfo_bitfield_1!(
3597 JSJitInfo_OpType::Method as u8,
3598 JSJitInfo_AliasSet::AliasEverything as u8,
3599 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3600 false,
3601 false,
3602 false,
3603 false,
3604 false,
3605 false,
3606 0,
3607 ).to_ne_bytes()
3608 ),
3609});
3610}
3611unsafe extern "C" fn drawArrays<D: DomTypes>
3612(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3613 let mut result = false;
3614 wrap_panic(&mut || result = (|| {
3615 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3616 let this = &*(this as *const D::WebGLRenderingContext);
3617 let args = &*args;
3618 let argc = args.argc_;
3619
3620 if argc < 3 {
3621 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.drawArrays\".");
3622 return false;
3623 }
3624 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3625 Ok(ConversionResult::Success(value)) => value,
3626 Ok(ConversionResult::Failure(error)) => {
3627 throw_type_error(cx.raw_cx(), &error);
3628 return false;
3629
3630 }
3631 _ => {
3632 return false;
3633
3634 },
3635 }
3636 ;
3637 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3638 Ok(ConversionResult::Success(value)) => value,
3639 Ok(ConversionResult::Failure(error)) => {
3640 throw_type_error(cx.raw_cx(), &error);
3641 return false;
3642
3643 }
3644 _ => {
3645 return false;
3646
3647 },
3648 }
3649 ;
3650 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
3651 Ok(ConversionResult::Success(value)) => value,
3652 Ok(ConversionResult::Failure(error)) => {
3653 throw_type_error(cx.raw_cx(), &error);
3654 return false;
3655
3656 }
3657 _ => {
3658 return false;
3659
3660 },
3661 }
3662 ;
3663 let result: () = this.DrawArrays(arg0, arg1, arg2);
3664
3665 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3666 return true;
3667 })());
3668 result
3669}
3670
3671
3672static drawArrays_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3673
3674pub(crate) fn init_drawArrays_methodinfo<D: DomTypes>() {
3675 drawArrays_methodinfo.set(JSJitInfo {
3676 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3677 method: Some(drawArrays::<D>)
3678 },
3679 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3680 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3681 },
3682 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3683 _bitfield_align_1: [],
3684 _bitfield_1: __BindgenBitfieldUnit::new(
3685 new_jsjitinfo_bitfield_1!(
3686 JSJitInfo_OpType::Method as u8,
3687 JSJitInfo_AliasSet::AliasEverything as u8,
3688 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3689 false,
3690 false,
3691 false,
3692 false,
3693 false,
3694 false,
3695 0,
3696 ).to_ne_bytes()
3697 ),
3698});
3699}
3700unsafe extern "C" fn drawElements<D: DomTypes>
3701(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3702 let mut result = false;
3703 wrap_panic(&mut || result = (|| {
3704 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3705 let this = &*(this as *const D::WebGLRenderingContext);
3706 let args = &*args;
3707 let argc = args.argc_;
3708
3709 if argc < 4 {
3710 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.drawElements\".");
3711 return false;
3712 }
3713 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3714 Ok(ConversionResult::Success(value)) => value,
3715 Ok(ConversionResult::Failure(error)) => {
3716 throw_type_error(cx.raw_cx(), &error);
3717 return false;
3718
3719 }
3720 _ => {
3721 return false;
3722
3723 },
3724 }
3725 ;
3726 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
3727 Ok(ConversionResult::Success(value)) => value,
3728 Ok(ConversionResult::Failure(error)) => {
3729 throw_type_error(cx.raw_cx(), &error);
3730 return false;
3731
3732 }
3733 _ => {
3734 return false;
3735
3736 },
3737 }
3738 ;
3739 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
3740 Ok(ConversionResult::Success(value)) => value,
3741 Ok(ConversionResult::Failure(error)) => {
3742 throw_type_error(cx.raw_cx(), &error);
3743 return false;
3744
3745 }
3746 _ => {
3747 return false;
3748
3749 },
3750 }
3751 ;
3752 let arg3: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
3753 Ok(ConversionResult::Success(value)) => value,
3754 Ok(ConversionResult::Failure(error)) => {
3755 throw_type_error(cx.raw_cx(), &error);
3756 return false;
3757
3758 }
3759 _ => {
3760 return false;
3761
3762 },
3763 }
3764 ;
3765 let result: () = this.DrawElements(arg0, arg1, arg2, arg3);
3766
3767 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3768 return true;
3769 })());
3770 result
3771}
3772
3773
3774static drawElements_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3775
3776pub(crate) fn init_drawElements_methodinfo<D: DomTypes>() {
3777 drawElements_methodinfo.set(JSJitInfo {
3778 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3779 method: Some(drawElements::<D>)
3780 },
3781 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3782 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3783 },
3784 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3785 _bitfield_align_1: [],
3786 _bitfield_1: __BindgenBitfieldUnit::new(
3787 new_jsjitinfo_bitfield_1!(
3788 JSJitInfo_OpType::Method as u8,
3789 JSJitInfo_AliasSet::AliasEverything as u8,
3790 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3791 false,
3792 false,
3793 false,
3794 false,
3795 false,
3796 false,
3797 0,
3798 ).to_ne_bytes()
3799 ),
3800});
3801}
3802unsafe extern "C" fn enable<D: DomTypes>
3803(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3804 let mut result = false;
3805 wrap_panic(&mut || result = (|| {
3806 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3807 let this = &*(this as *const D::WebGLRenderingContext);
3808 let args = &*args;
3809 let argc = args.argc_;
3810
3811 if argc < 1 {
3812 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.enable\".");
3813 return false;
3814 }
3815 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3816 Ok(ConversionResult::Success(value)) => value,
3817 Ok(ConversionResult::Failure(error)) => {
3818 throw_type_error(cx.raw_cx(), &error);
3819 return false;
3820
3821 }
3822 _ => {
3823 return false;
3824
3825 },
3826 }
3827 ;
3828 let result: () = this.Enable(arg0);
3829
3830 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3831 return true;
3832 })());
3833 result
3834}
3835
3836
3837static enable_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3838
3839pub(crate) fn init_enable_methodinfo<D: DomTypes>() {
3840 enable_methodinfo.set(JSJitInfo {
3841 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3842 method: Some(enable::<D>)
3843 },
3844 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3845 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3846 },
3847 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3848 _bitfield_align_1: [],
3849 _bitfield_1: __BindgenBitfieldUnit::new(
3850 new_jsjitinfo_bitfield_1!(
3851 JSJitInfo_OpType::Method as u8,
3852 JSJitInfo_AliasSet::AliasEverything as u8,
3853 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3854 false,
3855 false,
3856 false,
3857 false,
3858 false,
3859 false,
3860 0,
3861 ).to_ne_bytes()
3862 ),
3863});
3864}
3865unsafe extern "C" fn enableVertexAttribArray<D: DomTypes>
3866(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3867 let mut result = false;
3868 wrap_panic(&mut || result = (|| {
3869 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3870 let this = &*(this as *const D::WebGLRenderingContext);
3871 let args = &*args;
3872 let argc = args.argc_;
3873
3874 if argc < 1 {
3875 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.enableVertexAttribArray\".");
3876 return false;
3877 }
3878 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3879 Ok(ConversionResult::Success(value)) => value,
3880 Ok(ConversionResult::Failure(error)) => {
3881 throw_type_error(cx.raw_cx(), &error);
3882 return false;
3883
3884 }
3885 _ => {
3886 return false;
3887
3888 },
3889 }
3890 ;
3891 let result: () = this.EnableVertexAttribArray(arg0);
3892
3893 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3894 return true;
3895 })());
3896 result
3897}
3898
3899
3900static enableVertexAttribArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3901
3902pub(crate) fn init_enableVertexAttribArray_methodinfo<D: DomTypes>() {
3903 enableVertexAttribArray_methodinfo.set(JSJitInfo {
3904 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3905 method: Some(enableVertexAttribArray::<D>)
3906 },
3907 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3908 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3909 },
3910 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3911 _bitfield_align_1: [],
3912 _bitfield_1: __BindgenBitfieldUnit::new(
3913 new_jsjitinfo_bitfield_1!(
3914 JSJitInfo_OpType::Method as u8,
3915 JSJitInfo_AliasSet::AliasEverything as u8,
3916 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3917 false,
3918 false,
3919 false,
3920 false,
3921 false,
3922 false,
3923 0,
3924 ).to_ne_bytes()
3925 ),
3926});
3927}
3928unsafe extern "C" fn finish<D: DomTypes>
3929(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3930 let mut result = false;
3931 wrap_panic(&mut || result = (|| {
3932 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3933 let this = &*(this as *const D::WebGLRenderingContext);
3934 let args = &*args;
3935 let argc = args.argc_;
3936 let result: () = this.Finish();
3937
3938 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3939 return true;
3940 })());
3941 result
3942}
3943
3944
3945static finish_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3946
3947pub(crate) fn init_finish_methodinfo<D: DomTypes>() {
3948 finish_methodinfo.set(JSJitInfo {
3949 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3950 method: Some(finish::<D>)
3951 },
3952 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3953 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3954 },
3955 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3956 _bitfield_align_1: [],
3957 _bitfield_1: __BindgenBitfieldUnit::new(
3958 new_jsjitinfo_bitfield_1!(
3959 JSJitInfo_OpType::Method as u8,
3960 JSJitInfo_AliasSet::AliasEverything as u8,
3961 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3962 true,
3963 false,
3964 false,
3965 false,
3966 false,
3967 false,
3968 0,
3969 ).to_ne_bytes()
3970 ),
3971});
3972}
3973unsafe extern "C" fn flush<D: DomTypes>
3974(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3975 let mut result = false;
3976 wrap_panic(&mut || result = (|| {
3977 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3978 let this = &*(this as *const D::WebGLRenderingContext);
3979 let args = &*args;
3980 let argc = args.argc_;
3981 let result: () = this.Flush();
3982
3983 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3984 return true;
3985 })());
3986 result
3987}
3988
3989
3990static flush_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3991
3992pub(crate) fn init_flush_methodinfo<D: DomTypes>() {
3993 flush_methodinfo.set(JSJitInfo {
3994 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3995 method: Some(flush::<D>)
3996 },
3997 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3998 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
3999 },
4000 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4001 _bitfield_align_1: [],
4002 _bitfield_1: __BindgenBitfieldUnit::new(
4003 new_jsjitinfo_bitfield_1!(
4004 JSJitInfo_OpType::Method as u8,
4005 JSJitInfo_AliasSet::AliasEverything as u8,
4006 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4007 true,
4008 false,
4009 false,
4010 false,
4011 false,
4012 false,
4013 0,
4014 ).to_ne_bytes()
4015 ),
4016});
4017}
4018unsafe extern "C" fn framebufferRenderbuffer<D: DomTypes>
4019(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4020 let mut result = false;
4021 wrap_panic(&mut || result = (|| {
4022 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4023 let this = &*(this as *const D::WebGLRenderingContext);
4024 let args = &*args;
4025 let argc = args.argc_;
4026
4027 if argc < 4 {
4028 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.framebufferRenderbuffer\".");
4029 return false;
4030 }
4031 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4032 Ok(ConversionResult::Success(value)) => value,
4033 Ok(ConversionResult::Failure(error)) => {
4034 throw_type_error(cx.raw_cx(), &error);
4035 return false;
4036
4037 }
4038 _ => {
4039 return false;
4040
4041 },
4042 }
4043 ;
4044 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4045 Ok(ConversionResult::Success(value)) => value,
4046 Ok(ConversionResult::Failure(error)) => {
4047 throw_type_error(cx.raw_cx(), &error);
4048 return false;
4049
4050 }
4051 _ => {
4052 return false;
4053
4054 },
4055 }
4056 ;
4057 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
4058 Ok(ConversionResult::Success(value)) => value,
4059 Ok(ConversionResult::Failure(error)) => {
4060 throw_type_error(cx.raw_cx(), &error);
4061 return false;
4062
4063 }
4064 _ => {
4065 return false;
4066
4067 },
4068 }
4069 ;
4070 let arg3: Option<DomRoot<D::WebGLRenderbuffer>> = if HandleValue::from_raw(args.get(3)).get().is_object() {
4071 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(3)), SafeJSContext::from_ptr(cx.raw_cx())) {
4072 Ok(val) => val,
4073 Err(()) => {
4074 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLRenderbuffer.");
4075 return false;
4076
4077 }
4078 }
4079 )
4080 } else if HandleValue::from_raw(args.get(3)).get().is_null_or_undefined() {
4081 None
4082 } else {
4083 throw_type_error(cx.raw_cx(), "Value is not an object.");
4084 return false;
4085
4086 };
4087 let result: () = this.FramebufferRenderbuffer(arg0, arg1, arg2, arg3.as_deref());
4088
4089 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4090 return true;
4091 })());
4092 result
4093}
4094
4095
4096static framebufferRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4097
4098pub(crate) fn init_framebufferRenderbuffer_methodinfo<D: DomTypes>() {
4099 framebufferRenderbuffer_methodinfo.set(JSJitInfo {
4100 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4101 method: Some(framebufferRenderbuffer::<D>)
4102 },
4103 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4104 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4105 },
4106 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4107 _bitfield_align_1: [],
4108 _bitfield_1: __BindgenBitfieldUnit::new(
4109 new_jsjitinfo_bitfield_1!(
4110 JSJitInfo_OpType::Method as u8,
4111 JSJitInfo_AliasSet::AliasEverything as u8,
4112 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4113 false,
4114 false,
4115 false,
4116 false,
4117 false,
4118 false,
4119 0,
4120 ).to_ne_bytes()
4121 ),
4122});
4123}
4124unsafe extern "C" fn framebufferTexture2D<D: DomTypes>
4125(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4126 let mut result = false;
4127 wrap_panic(&mut || result = (|| {
4128 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4129 let this = &*(this as *const D::WebGLRenderingContext);
4130 let args = &*args;
4131 let argc = args.argc_;
4132
4133 if argc < 5 {
4134 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.framebufferTexture2D\".");
4135 return false;
4136 }
4137 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4138 Ok(ConversionResult::Success(value)) => value,
4139 Ok(ConversionResult::Failure(error)) => {
4140 throw_type_error(cx.raw_cx(), &error);
4141 return false;
4142
4143 }
4144 _ => {
4145 return false;
4146
4147 },
4148 }
4149 ;
4150 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4151 Ok(ConversionResult::Success(value)) => value,
4152 Ok(ConversionResult::Failure(error)) => {
4153 throw_type_error(cx.raw_cx(), &error);
4154 return false;
4155
4156 }
4157 _ => {
4158 return false;
4159
4160 },
4161 }
4162 ;
4163 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
4164 Ok(ConversionResult::Success(value)) => value,
4165 Ok(ConversionResult::Failure(error)) => {
4166 throw_type_error(cx.raw_cx(), &error);
4167 return false;
4168
4169 }
4170 _ => {
4171 return false;
4172
4173 },
4174 }
4175 ;
4176 let arg3: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(3)).get().is_object() {
4177 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(3)), SafeJSContext::from_ptr(cx.raw_cx())) {
4178 Ok(val) => val,
4179 Err(()) => {
4180 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
4181 return false;
4182
4183 }
4184 }
4185 )
4186 } else if HandleValue::from_raw(args.get(3)).get().is_null_or_undefined() {
4187 None
4188 } else {
4189 throw_type_error(cx.raw_cx(), "Value is not an object.");
4190 return false;
4191
4192 };
4193 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
4194 Ok(ConversionResult::Success(value)) => value,
4195 Ok(ConversionResult::Failure(error)) => {
4196 throw_type_error(cx.raw_cx(), &error);
4197 return false;
4198
4199 }
4200 _ => {
4201 return false;
4202
4203 },
4204 }
4205 ;
4206 let result: () = this.FramebufferTexture2D(arg0, arg1, arg2, arg3.as_deref(), arg4);
4207
4208 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4209 return true;
4210 })());
4211 result
4212}
4213
4214
4215static framebufferTexture2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4216
4217pub(crate) fn init_framebufferTexture2D_methodinfo<D: DomTypes>() {
4218 framebufferTexture2D_methodinfo.set(JSJitInfo {
4219 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4220 method: Some(framebufferTexture2D::<D>)
4221 },
4222 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4223 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4224 },
4225 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4226 _bitfield_align_1: [],
4227 _bitfield_1: __BindgenBitfieldUnit::new(
4228 new_jsjitinfo_bitfield_1!(
4229 JSJitInfo_OpType::Method as u8,
4230 JSJitInfo_AliasSet::AliasEverything as u8,
4231 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4232 false,
4233 false,
4234 false,
4235 false,
4236 false,
4237 false,
4238 0,
4239 ).to_ne_bytes()
4240 ),
4241});
4242}
4243unsafe extern "C" fn frontFace<D: DomTypes>
4244(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4245 let mut result = false;
4246 wrap_panic(&mut || result = (|| {
4247 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4248 let this = &*(this as *const D::WebGLRenderingContext);
4249 let args = &*args;
4250 let argc = args.argc_;
4251
4252 if argc < 1 {
4253 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.frontFace\".");
4254 return false;
4255 }
4256 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4257 Ok(ConversionResult::Success(value)) => value,
4258 Ok(ConversionResult::Failure(error)) => {
4259 throw_type_error(cx.raw_cx(), &error);
4260 return false;
4261
4262 }
4263 _ => {
4264 return false;
4265
4266 },
4267 }
4268 ;
4269 let result: () = this.FrontFace(arg0);
4270
4271 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4272 return true;
4273 })());
4274 result
4275}
4276
4277
4278static frontFace_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4279
4280pub(crate) fn init_frontFace_methodinfo<D: DomTypes>() {
4281 frontFace_methodinfo.set(JSJitInfo {
4282 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4283 method: Some(frontFace::<D>)
4284 },
4285 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4286 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4287 },
4288 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4289 _bitfield_align_1: [],
4290 _bitfield_1: __BindgenBitfieldUnit::new(
4291 new_jsjitinfo_bitfield_1!(
4292 JSJitInfo_OpType::Method as u8,
4293 JSJitInfo_AliasSet::AliasEverything as u8,
4294 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4295 false,
4296 false,
4297 false,
4298 false,
4299 false,
4300 false,
4301 0,
4302 ).to_ne_bytes()
4303 ),
4304});
4305}
4306unsafe extern "C" fn generateMipmap<D: DomTypes>
4307(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4308 let mut result = false;
4309 wrap_panic(&mut || result = (|| {
4310 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4311 let this = &*(this as *const D::WebGLRenderingContext);
4312 let args = &*args;
4313 let argc = args.argc_;
4314
4315 if argc < 1 {
4316 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.generateMipmap\".");
4317 return false;
4318 }
4319 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4320 Ok(ConversionResult::Success(value)) => value,
4321 Ok(ConversionResult::Failure(error)) => {
4322 throw_type_error(cx.raw_cx(), &error);
4323 return false;
4324
4325 }
4326 _ => {
4327 return false;
4328
4329 },
4330 }
4331 ;
4332 let result: () = this.GenerateMipmap(arg0);
4333
4334 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4335 return true;
4336 })());
4337 result
4338}
4339
4340
4341static generateMipmap_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4342
4343pub(crate) fn init_generateMipmap_methodinfo<D: DomTypes>() {
4344 generateMipmap_methodinfo.set(JSJitInfo {
4345 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4346 method: Some(generateMipmap::<D>)
4347 },
4348 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4349 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4350 },
4351 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4352 _bitfield_align_1: [],
4353 _bitfield_1: __BindgenBitfieldUnit::new(
4354 new_jsjitinfo_bitfield_1!(
4355 JSJitInfo_OpType::Method as u8,
4356 JSJitInfo_AliasSet::AliasEverything as u8,
4357 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4358 false,
4359 false,
4360 false,
4361 false,
4362 false,
4363 false,
4364 0,
4365 ).to_ne_bytes()
4366 ),
4367});
4368}
4369unsafe extern "C" fn getActiveAttrib<D: DomTypes>
4370(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4371 let mut result = false;
4372 wrap_panic(&mut || result = (|| {
4373 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4374 let this = &*(this as *const D::WebGLRenderingContext);
4375 let args = &*args;
4376 let argc = args.argc_;
4377
4378 if argc < 2 {
4379 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getActiveAttrib\".");
4380 return false;
4381 }
4382 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4383 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4384 Ok(val) => val,
4385 Err(()) => {
4386 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
4387 return false;
4388
4389 }
4390 }
4391
4392 } else {
4393 throw_type_error(cx.raw_cx(), "Value is not an object.");
4394 return false;
4395
4396 };
4397 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4398 Ok(ConversionResult::Success(value)) => value,
4399 Ok(ConversionResult::Failure(error)) => {
4400 throw_type_error(cx.raw_cx(), &error);
4401 return false;
4402
4403 }
4404 _ => {
4405 return false;
4406
4407 },
4408 }
4409 ;
4410 let result: Option<DomRoot<D::WebGLActiveInfo>> = this.GetActiveAttrib(&arg0, arg1);
4411
4412 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4413 return true;
4414 })());
4415 result
4416}
4417
4418
4419static getActiveAttrib_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4420
4421pub(crate) fn init_getActiveAttrib_methodinfo<D: DomTypes>() {
4422 getActiveAttrib_methodinfo.set(JSJitInfo {
4423 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4424 method: Some(getActiveAttrib::<D>)
4425 },
4426 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4427 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4428 },
4429 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4430 _bitfield_align_1: [],
4431 _bitfield_1: __BindgenBitfieldUnit::new(
4432 new_jsjitinfo_bitfield_1!(
4433 JSJitInfo_OpType::Method as u8,
4434 JSJitInfo_AliasSet::AliasEverything as u8,
4435 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4436 false,
4437 false,
4438 false,
4439 false,
4440 false,
4441 false,
4442 0,
4443 ).to_ne_bytes()
4444 ),
4445});
4446}
4447unsafe extern "C" fn getActiveUniform<D: DomTypes>
4448(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4449 let mut result = false;
4450 wrap_panic(&mut || result = (|| {
4451 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4452 let this = &*(this as *const D::WebGLRenderingContext);
4453 let args = &*args;
4454 let argc = args.argc_;
4455
4456 if argc < 2 {
4457 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getActiveUniform\".");
4458 return false;
4459 }
4460 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4461 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4462 Ok(val) => val,
4463 Err(()) => {
4464 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
4465 return false;
4466
4467 }
4468 }
4469
4470 } else {
4471 throw_type_error(cx.raw_cx(), "Value is not an object.");
4472 return false;
4473
4474 };
4475 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4476 Ok(ConversionResult::Success(value)) => value,
4477 Ok(ConversionResult::Failure(error)) => {
4478 throw_type_error(cx.raw_cx(), &error);
4479 return false;
4480
4481 }
4482 _ => {
4483 return false;
4484
4485 },
4486 }
4487 ;
4488 let result: Option<DomRoot<D::WebGLActiveInfo>> = this.GetActiveUniform(&arg0, arg1);
4489
4490 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4491 return true;
4492 })());
4493 result
4494}
4495
4496
4497static getActiveUniform_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4498
4499pub(crate) fn init_getActiveUniform_methodinfo<D: DomTypes>() {
4500 getActiveUniform_methodinfo.set(JSJitInfo {
4501 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4502 method: Some(getActiveUniform::<D>)
4503 },
4504 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4505 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4506 },
4507 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4508 _bitfield_align_1: [],
4509 _bitfield_1: __BindgenBitfieldUnit::new(
4510 new_jsjitinfo_bitfield_1!(
4511 JSJitInfo_OpType::Method as u8,
4512 JSJitInfo_AliasSet::AliasEverything as u8,
4513 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4514 false,
4515 false,
4516 false,
4517 false,
4518 false,
4519 false,
4520 0,
4521 ).to_ne_bytes()
4522 ),
4523});
4524}
4525unsafe extern "C" fn getAttachedShaders<D: DomTypes>
4526(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4527 let mut result = false;
4528 wrap_panic(&mut || result = (|| {
4529 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4530 let this = &*(this as *const D::WebGLRenderingContext);
4531 let args = &*args;
4532 let argc = args.argc_;
4533
4534 if argc < 1 {
4535 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getAttachedShaders\".");
4536 return false;
4537 }
4538 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4539 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4540 Ok(val) => val,
4541 Err(()) => {
4542 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
4543 return false;
4544
4545 }
4546 }
4547
4548 } else {
4549 throw_type_error(cx.raw_cx(), "Value is not an object.");
4550 return false;
4551
4552 };
4553 let result: Option<Vec<DomRoot<D::WebGLShader>>> = this.GetAttachedShaders(&arg0);
4554
4555 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4556 return true;
4557 })());
4558 result
4559}
4560
4561
4562static getAttachedShaders_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4563
4564pub(crate) fn init_getAttachedShaders_methodinfo<D: DomTypes>() {
4565 getAttachedShaders_methodinfo.set(JSJitInfo {
4566 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4567 method: Some(getAttachedShaders::<D>)
4568 },
4569 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4570 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4571 },
4572 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4573 _bitfield_align_1: [],
4574 _bitfield_1: __BindgenBitfieldUnit::new(
4575 new_jsjitinfo_bitfield_1!(
4576 JSJitInfo_OpType::Method as u8,
4577 JSJitInfo_AliasSet::AliasEverything as u8,
4578 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4579 false,
4580 false,
4581 false,
4582 false,
4583 false,
4584 false,
4585 0,
4586 ).to_ne_bytes()
4587 ),
4588});
4589}
4590unsafe extern "C" fn getAttribLocation<D: DomTypes>
4591(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4592 let mut result = false;
4593 wrap_panic(&mut || result = (|| {
4594 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4595 let this = &*(this as *const D::WebGLRenderingContext);
4596 let args = &*args;
4597 let argc = args.argc_;
4598
4599 if argc < 2 {
4600 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getAttribLocation\".");
4601 return false;
4602 }
4603 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4604 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4605 Ok(val) => val,
4606 Err(()) => {
4607 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
4608 return false;
4609
4610 }
4611 }
4612
4613 } else {
4614 throw_type_error(cx.raw_cx(), "Value is not an object.");
4615 return false;
4616
4617 };
4618 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
4619 Ok(ConversionResult::Success(value)) => value,
4620 Ok(ConversionResult::Failure(error)) => {
4621 throw_type_error(cx.raw_cx(), &error);
4622 return false;
4623
4624 }
4625 _ => {
4626 return false;
4627
4628 },
4629 }
4630 ;
4631 let result: i32 = this.GetAttribLocation(&arg0, arg1);
4632
4633 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4634 return true;
4635 })());
4636 result
4637}
4638
4639
4640static getAttribLocation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4641
4642pub(crate) fn init_getAttribLocation_methodinfo<D: DomTypes>() {
4643 getAttribLocation_methodinfo.set(JSJitInfo {
4644 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4645 method: Some(getAttribLocation::<D>)
4646 },
4647 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4648 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4649 },
4650 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4651 _bitfield_align_1: [],
4652 _bitfield_1: __BindgenBitfieldUnit::new(
4653 new_jsjitinfo_bitfield_1!(
4654 JSJitInfo_OpType::Method as u8,
4655 JSJitInfo_AliasSet::AliasEverything as u8,
4656 JSValueType::JSVAL_TYPE_INT32 as u8,
4657 false,
4658 false,
4659 false,
4660 false,
4661 false,
4662 false,
4663 0,
4664 ).to_ne_bytes()
4665 ),
4666});
4667}
4668unsafe extern "C" fn getBufferParameter<D: DomTypes>
4669(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4670 let mut result = false;
4671 wrap_panic(&mut || result = (|| {
4672 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4673 let this = &*(this as *const D::WebGLRenderingContext);
4674 let args = &*args;
4675 let argc = args.argc_;
4676
4677 if argc < 2 {
4678 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getBufferParameter\".");
4679 return false;
4680 }
4681 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4682 Ok(ConversionResult::Success(value)) => value,
4683 Ok(ConversionResult::Failure(error)) => {
4684 throw_type_error(cx.raw_cx(), &error);
4685 return false;
4686
4687 }
4688 _ => {
4689 return false;
4690
4691 },
4692 }
4693 ;
4694 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4695 Ok(ConversionResult::Success(value)) => value,
4696 Ok(ConversionResult::Failure(error)) => {
4697 throw_type_error(cx.raw_cx(), &error);
4698 return false;
4699
4700 }
4701 _ => {
4702 return false;
4703
4704 },
4705 }
4706 ;
4707 rooted!(&in(cx) let mut retval: JSVal);
4708 let result: () = this.GetBufferParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
4709
4710 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4711 return true;
4712 })());
4713 result
4714}
4715
4716
4717static getBufferParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4718
4719pub(crate) fn init_getBufferParameter_methodinfo<D: DomTypes>() {
4720 getBufferParameter_methodinfo.set(JSJitInfo {
4721 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4722 method: Some(getBufferParameter::<D>)
4723 },
4724 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4725 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4726 },
4727 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4728 _bitfield_align_1: [],
4729 _bitfield_1: __BindgenBitfieldUnit::new(
4730 new_jsjitinfo_bitfield_1!(
4731 JSJitInfo_OpType::Method as u8,
4732 JSJitInfo_AliasSet::AliasEverything as u8,
4733 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4734 false,
4735 false,
4736 false,
4737 false,
4738 false,
4739 false,
4740 0,
4741 ).to_ne_bytes()
4742 ),
4743});
4744}
4745unsafe extern "C" fn getParameter<D: DomTypes>
4746(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4747 let mut result = false;
4748 wrap_panic(&mut || result = (|| {
4749 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4750 let this = &*(this as *const D::WebGLRenderingContext);
4751 let args = &*args;
4752 let argc = args.argc_;
4753
4754 if argc < 1 {
4755 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getParameter\".");
4756 return false;
4757 }
4758 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4759 Ok(ConversionResult::Success(value)) => value,
4760 Ok(ConversionResult::Failure(error)) => {
4761 throw_type_error(cx.raw_cx(), &error);
4762 return false;
4763
4764 }
4765 _ => {
4766 return false;
4767
4768 },
4769 }
4770 ;
4771 rooted!(&in(cx) let mut retval: JSVal);
4772 let result: () = this.GetParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, retval.handle_mut());
4773
4774 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4775 return true;
4776 })());
4777 result
4778}
4779
4780
4781static getParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4782
4783pub(crate) fn init_getParameter_methodinfo<D: DomTypes>() {
4784 getParameter_methodinfo.set(JSJitInfo {
4785 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4786 method: Some(getParameter::<D>)
4787 },
4788 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4789 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4790 },
4791 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4792 _bitfield_align_1: [],
4793 _bitfield_1: __BindgenBitfieldUnit::new(
4794 new_jsjitinfo_bitfield_1!(
4795 JSJitInfo_OpType::Method as u8,
4796 JSJitInfo_AliasSet::AliasEverything as u8,
4797 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4798 false,
4799 false,
4800 false,
4801 false,
4802 false,
4803 false,
4804 0,
4805 ).to_ne_bytes()
4806 ),
4807});
4808}
4809unsafe extern "C" fn getError<D: DomTypes>
4810(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4811 let mut result = false;
4812 wrap_panic(&mut || result = (|| {
4813 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4814 let this = &*(this as *const D::WebGLRenderingContext);
4815 let args = &*args;
4816 let argc = args.argc_;
4817 let result: u32 = this.GetError();
4818
4819 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4820 return true;
4821 })());
4822 result
4823}
4824
4825
4826static getError_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4827
4828pub(crate) fn init_getError_methodinfo<D: DomTypes>() {
4829 getError_methodinfo.set(JSJitInfo {
4830 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4831 method: Some(getError::<D>)
4832 },
4833 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4834 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4835 },
4836 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4837 _bitfield_align_1: [],
4838 _bitfield_1: __BindgenBitfieldUnit::new(
4839 new_jsjitinfo_bitfield_1!(
4840 JSJitInfo_OpType::Method as u8,
4841 JSJitInfo_AliasSet::AliasEverything as u8,
4842 JSValueType::JSVAL_TYPE_DOUBLE as u8,
4843 true,
4844 false,
4845 false,
4846 false,
4847 false,
4848 false,
4849 0,
4850 ).to_ne_bytes()
4851 ),
4852});
4853}
4854unsafe extern "C" fn getFramebufferAttachmentParameter<D: DomTypes>
4855(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4856 let mut result = false;
4857 wrap_panic(&mut || result = (|| {
4858 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4859 let this = &*(this as *const D::WebGLRenderingContext);
4860 let args = &*args;
4861 let argc = args.argc_;
4862
4863 if argc < 3 {
4864 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getFramebufferAttachmentParameter\".");
4865 return false;
4866 }
4867 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4868 Ok(ConversionResult::Success(value)) => value,
4869 Ok(ConversionResult::Failure(error)) => {
4870 throw_type_error(cx.raw_cx(), &error);
4871 return false;
4872
4873 }
4874 _ => {
4875 return false;
4876
4877 },
4878 }
4879 ;
4880 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4881 Ok(ConversionResult::Success(value)) => value,
4882 Ok(ConversionResult::Failure(error)) => {
4883 throw_type_error(cx.raw_cx(), &error);
4884 return false;
4885
4886 }
4887 _ => {
4888 return false;
4889
4890 },
4891 }
4892 ;
4893 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
4894 Ok(ConversionResult::Success(value)) => value,
4895 Ok(ConversionResult::Failure(error)) => {
4896 throw_type_error(cx.raw_cx(), &error);
4897 return false;
4898
4899 }
4900 _ => {
4901 return false;
4902
4903 },
4904 }
4905 ;
4906 rooted!(&in(cx) let mut retval: JSVal);
4907 let result: () = this.GetFramebufferAttachmentParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, arg2, retval.handle_mut());
4908
4909 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4910 return true;
4911 })());
4912 result
4913}
4914
4915
4916static getFramebufferAttachmentParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4917
4918pub(crate) fn init_getFramebufferAttachmentParameter_methodinfo<D: DomTypes>() {
4919 getFramebufferAttachmentParameter_methodinfo.set(JSJitInfo {
4920 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4921 method: Some(getFramebufferAttachmentParameter::<D>)
4922 },
4923 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4924 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
4925 },
4926 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4927 _bitfield_align_1: [],
4928 _bitfield_1: __BindgenBitfieldUnit::new(
4929 new_jsjitinfo_bitfield_1!(
4930 JSJitInfo_OpType::Method as u8,
4931 JSJitInfo_AliasSet::AliasEverything as u8,
4932 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4933 false,
4934 false,
4935 false,
4936 false,
4937 false,
4938 false,
4939 0,
4940 ).to_ne_bytes()
4941 ),
4942});
4943}
4944unsafe extern "C" fn getProgramParameter<D: DomTypes>
4945(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4946 let mut result = false;
4947 wrap_panic(&mut || result = (|| {
4948 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4949 let this = &*(this as *const D::WebGLRenderingContext);
4950 let args = &*args;
4951 let argc = args.argc_;
4952
4953 if argc < 2 {
4954 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getProgramParameter\".");
4955 return false;
4956 }
4957 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4958 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4959 Ok(val) => val,
4960 Err(()) => {
4961 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
4962 return false;
4963
4964 }
4965 }
4966
4967 } else {
4968 throw_type_error(cx.raw_cx(), "Value is not an object.");
4969 return false;
4970
4971 };
4972 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4973 Ok(ConversionResult::Success(value)) => value,
4974 Ok(ConversionResult::Failure(error)) => {
4975 throw_type_error(cx.raw_cx(), &error);
4976 return false;
4977
4978 }
4979 _ => {
4980 return false;
4981
4982 },
4983 }
4984 ;
4985 rooted!(&in(cx) let mut retval: JSVal);
4986 let result: () = this.GetProgramParameter(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, retval.handle_mut());
4987
4988 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4989 return true;
4990 })());
4991 result
4992}
4993
4994
4995static getProgramParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4996
4997pub(crate) fn init_getProgramParameter_methodinfo<D: DomTypes>() {
4998 getProgramParameter_methodinfo.set(JSJitInfo {
4999 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5000 method: Some(getProgramParameter::<D>)
5001 },
5002 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5003 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5004 },
5005 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5006 _bitfield_align_1: [],
5007 _bitfield_1: __BindgenBitfieldUnit::new(
5008 new_jsjitinfo_bitfield_1!(
5009 JSJitInfo_OpType::Method as u8,
5010 JSJitInfo_AliasSet::AliasEverything as u8,
5011 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5012 false,
5013 false,
5014 false,
5015 false,
5016 false,
5017 false,
5018 0,
5019 ).to_ne_bytes()
5020 ),
5021});
5022}
5023unsafe extern "C" fn getProgramInfoLog<D: DomTypes>
5024(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5025 let mut result = false;
5026 wrap_panic(&mut || result = (|| {
5027 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5028 let this = &*(this as *const D::WebGLRenderingContext);
5029 let args = &*args;
5030 let argc = args.argc_;
5031
5032 if argc < 1 {
5033 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getProgramInfoLog\".");
5034 return false;
5035 }
5036 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5037 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5038 Ok(val) => val,
5039 Err(()) => {
5040 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
5041 return false;
5042
5043 }
5044 }
5045
5046 } else {
5047 throw_type_error(cx.raw_cx(), "Value is not an object.");
5048 return false;
5049
5050 };
5051 let result: Option<DOMString> = this.GetProgramInfoLog(&arg0);
5052
5053 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5054 return true;
5055 })());
5056 result
5057}
5058
5059
5060static getProgramInfoLog_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5061
5062pub(crate) fn init_getProgramInfoLog_methodinfo<D: DomTypes>() {
5063 getProgramInfoLog_methodinfo.set(JSJitInfo {
5064 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5065 method: Some(getProgramInfoLog::<D>)
5066 },
5067 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5068 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5069 },
5070 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5071 _bitfield_align_1: [],
5072 _bitfield_1: __BindgenBitfieldUnit::new(
5073 new_jsjitinfo_bitfield_1!(
5074 JSJitInfo_OpType::Method as u8,
5075 JSJitInfo_AliasSet::AliasEverything as u8,
5076 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5077 false,
5078 false,
5079 false,
5080 false,
5081 false,
5082 false,
5083 0,
5084 ).to_ne_bytes()
5085 ),
5086});
5087}
5088unsafe extern "C" fn getRenderbufferParameter<D: DomTypes>
5089(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5090 let mut result = false;
5091 wrap_panic(&mut || result = (|| {
5092 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5093 let this = &*(this as *const D::WebGLRenderingContext);
5094 let args = &*args;
5095 let argc = args.argc_;
5096
5097 if argc < 2 {
5098 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getRenderbufferParameter\".");
5099 return false;
5100 }
5101 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5102 Ok(ConversionResult::Success(value)) => value,
5103 Ok(ConversionResult::Failure(error)) => {
5104 throw_type_error(cx.raw_cx(), &error);
5105 return false;
5106
5107 }
5108 _ => {
5109 return false;
5110
5111 },
5112 }
5113 ;
5114 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5115 Ok(ConversionResult::Success(value)) => value,
5116 Ok(ConversionResult::Failure(error)) => {
5117 throw_type_error(cx.raw_cx(), &error);
5118 return false;
5119
5120 }
5121 _ => {
5122 return false;
5123
5124 },
5125 }
5126 ;
5127 rooted!(&in(cx) let mut retval: JSVal);
5128 let result: () = this.GetRenderbufferParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
5129
5130 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5131 return true;
5132 })());
5133 result
5134}
5135
5136
5137static getRenderbufferParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5138
5139pub(crate) fn init_getRenderbufferParameter_methodinfo<D: DomTypes>() {
5140 getRenderbufferParameter_methodinfo.set(JSJitInfo {
5141 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5142 method: Some(getRenderbufferParameter::<D>)
5143 },
5144 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5145 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5146 },
5147 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5148 _bitfield_align_1: [],
5149 _bitfield_1: __BindgenBitfieldUnit::new(
5150 new_jsjitinfo_bitfield_1!(
5151 JSJitInfo_OpType::Method as u8,
5152 JSJitInfo_AliasSet::AliasEverything as u8,
5153 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5154 false,
5155 false,
5156 false,
5157 false,
5158 false,
5159 false,
5160 0,
5161 ).to_ne_bytes()
5162 ),
5163});
5164}
5165unsafe extern "C" fn getShaderParameter<D: DomTypes>
5166(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5167 let mut result = false;
5168 wrap_panic(&mut || result = (|| {
5169 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5170 let this = &*(this as *const D::WebGLRenderingContext);
5171 let args = &*args;
5172 let argc = args.argc_;
5173
5174 if argc < 2 {
5175 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getShaderParameter\".");
5176 return false;
5177 }
5178 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5179 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5180 Ok(val) => val,
5181 Err(()) => {
5182 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
5183 return false;
5184
5185 }
5186 }
5187
5188 } else {
5189 throw_type_error(cx.raw_cx(), "Value is not an object.");
5190 return false;
5191
5192 };
5193 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5194 Ok(ConversionResult::Success(value)) => value,
5195 Ok(ConversionResult::Failure(error)) => {
5196 throw_type_error(cx.raw_cx(), &error);
5197 return false;
5198
5199 }
5200 _ => {
5201 return false;
5202
5203 },
5204 }
5205 ;
5206 rooted!(&in(cx) let mut retval: JSVal);
5207 let result: () = this.GetShaderParameter(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, retval.handle_mut());
5208
5209 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5210 return true;
5211 })());
5212 result
5213}
5214
5215
5216static getShaderParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5217
5218pub(crate) fn init_getShaderParameter_methodinfo<D: DomTypes>() {
5219 getShaderParameter_methodinfo.set(JSJitInfo {
5220 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5221 method: Some(getShaderParameter::<D>)
5222 },
5223 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5224 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5225 },
5226 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5227 _bitfield_align_1: [],
5228 _bitfield_1: __BindgenBitfieldUnit::new(
5229 new_jsjitinfo_bitfield_1!(
5230 JSJitInfo_OpType::Method as u8,
5231 JSJitInfo_AliasSet::AliasEverything as u8,
5232 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5233 false,
5234 false,
5235 false,
5236 false,
5237 false,
5238 false,
5239 0,
5240 ).to_ne_bytes()
5241 ),
5242});
5243}
5244unsafe extern "C" fn getShaderPrecisionFormat<D: DomTypes>
5245(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5246 let mut result = false;
5247 wrap_panic(&mut || result = (|| {
5248 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5249 let this = &*(this as *const D::WebGLRenderingContext);
5250 let args = &*args;
5251 let argc = args.argc_;
5252
5253 if argc < 2 {
5254 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getShaderPrecisionFormat\".");
5255 return false;
5256 }
5257 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5258 Ok(ConversionResult::Success(value)) => value,
5259 Ok(ConversionResult::Failure(error)) => {
5260 throw_type_error(cx.raw_cx(), &error);
5261 return false;
5262
5263 }
5264 _ => {
5265 return false;
5266
5267 },
5268 }
5269 ;
5270 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5271 Ok(ConversionResult::Success(value)) => value,
5272 Ok(ConversionResult::Failure(error)) => {
5273 throw_type_error(cx.raw_cx(), &error);
5274 return false;
5275
5276 }
5277 _ => {
5278 return false;
5279
5280 },
5281 }
5282 ;
5283 let result: Option<DomRoot<D::WebGLShaderPrecisionFormat>> = this.GetShaderPrecisionFormat(arg0, arg1);
5284
5285 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5286 return true;
5287 })());
5288 result
5289}
5290
5291
5292static getShaderPrecisionFormat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5293
5294pub(crate) fn init_getShaderPrecisionFormat_methodinfo<D: DomTypes>() {
5295 getShaderPrecisionFormat_methodinfo.set(JSJitInfo {
5296 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5297 method: Some(getShaderPrecisionFormat::<D>)
5298 },
5299 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5300 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5301 },
5302 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5303 _bitfield_align_1: [],
5304 _bitfield_1: __BindgenBitfieldUnit::new(
5305 new_jsjitinfo_bitfield_1!(
5306 JSJitInfo_OpType::Method as u8,
5307 JSJitInfo_AliasSet::AliasEverything as u8,
5308 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5309 false,
5310 false,
5311 false,
5312 false,
5313 false,
5314 false,
5315 0,
5316 ).to_ne_bytes()
5317 ),
5318});
5319}
5320unsafe extern "C" fn getShaderInfoLog<D: DomTypes>
5321(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5322 let mut result = false;
5323 wrap_panic(&mut || result = (|| {
5324 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5325 let this = &*(this as *const D::WebGLRenderingContext);
5326 let args = &*args;
5327 let argc = args.argc_;
5328
5329 if argc < 1 {
5330 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getShaderInfoLog\".");
5331 return false;
5332 }
5333 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5334 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5335 Ok(val) => val,
5336 Err(()) => {
5337 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
5338 return false;
5339
5340 }
5341 }
5342
5343 } else {
5344 throw_type_error(cx.raw_cx(), "Value is not an object.");
5345 return false;
5346
5347 };
5348 let result: Option<DOMString> = this.GetShaderInfoLog(&arg0);
5349
5350 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5351 return true;
5352 })());
5353 result
5354}
5355
5356
5357static getShaderInfoLog_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5358
5359pub(crate) fn init_getShaderInfoLog_methodinfo<D: DomTypes>() {
5360 getShaderInfoLog_methodinfo.set(JSJitInfo {
5361 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5362 method: Some(getShaderInfoLog::<D>)
5363 },
5364 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5365 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5366 },
5367 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5368 _bitfield_align_1: [],
5369 _bitfield_1: __BindgenBitfieldUnit::new(
5370 new_jsjitinfo_bitfield_1!(
5371 JSJitInfo_OpType::Method as u8,
5372 JSJitInfo_AliasSet::AliasEverything as u8,
5373 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5374 false,
5375 false,
5376 false,
5377 false,
5378 false,
5379 false,
5380 0,
5381 ).to_ne_bytes()
5382 ),
5383});
5384}
5385unsafe extern "C" fn getShaderSource<D: DomTypes>
5386(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5387 let mut result = false;
5388 wrap_panic(&mut || result = (|| {
5389 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5390 let this = &*(this as *const D::WebGLRenderingContext);
5391 let args = &*args;
5392 let argc = args.argc_;
5393
5394 if argc < 1 {
5395 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getShaderSource\".");
5396 return false;
5397 }
5398 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5399 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5400 Ok(val) => val,
5401 Err(()) => {
5402 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
5403 return false;
5404
5405 }
5406 }
5407
5408 } else {
5409 throw_type_error(cx.raw_cx(), "Value is not an object.");
5410 return false;
5411
5412 };
5413 let result: Option<DOMString> = this.GetShaderSource(&arg0);
5414
5415 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5416 return true;
5417 })());
5418 result
5419}
5420
5421
5422static getShaderSource_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5423
5424pub(crate) fn init_getShaderSource_methodinfo<D: DomTypes>() {
5425 getShaderSource_methodinfo.set(JSJitInfo {
5426 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5427 method: Some(getShaderSource::<D>)
5428 },
5429 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5430 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5431 },
5432 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5433 _bitfield_align_1: [],
5434 _bitfield_1: __BindgenBitfieldUnit::new(
5435 new_jsjitinfo_bitfield_1!(
5436 JSJitInfo_OpType::Method as u8,
5437 JSJitInfo_AliasSet::AliasEverything as u8,
5438 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5439 false,
5440 false,
5441 false,
5442 false,
5443 false,
5444 false,
5445 0,
5446 ).to_ne_bytes()
5447 ),
5448});
5449}
5450unsafe extern "C" fn getTexParameter<D: DomTypes>
5451(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5452 let mut result = false;
5453 wrap_panic(&mut || result = (|| {
5454 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5455 let this = &*(this as *const D::WebGLRenderingContext);
5456 let args = &*args;
5457 let argc = args.argc_;
5458
5459 if argc < 2 {
5460 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getTexParameter\".");
5461 return false;
5462 }
5463 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5464 Ok(ConversionResult::Success(value)) => value,
5465 Ok(ConversionResult::Failure(error)) => {
5466 throw_type_error(cx.raw_cx(), &error);
5467 return false;
5468
5469 }
5470 _ => {
5471 return false;
5472
5473 },
5474 }
5475 ;
5476 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5477 Ok(ConversionResult::Success(value)) => value,
5478 Ok(ConversionResult::Failure(error)) => {
5479 throw_type_error(cx.raw_cx(), &error);
5480 return false;
5481
5482 }
5483 _ => {
5484 return false;
5485
5486 },
5487 }
5488 ;
5489 rooted!(&in(cx) let mut retval: JSVal);
5490 let result: () = this.GetTexParameter(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
5491
5492 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5493 return true;
5494 })());
5495 result
5496}
5497
5498
5499static getTexParameter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5500
5501pub(crate) fn init_getTexParameter_methodinfo<D: DomTypes>() {
5502 getTexParameter_methodinfo.set(JSJitInfo {
5503 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5504 method: Some(getTexParameter::<D>)
5505 },
5506 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5507 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5508 },
5509 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5510 _bitfield_align_1: [],
5511 _bitfield_1: __BindgenBitfieldUnit::new(
5512 new_jsjitinfo_bitfield_1!(
5513 JSJitInfo_OpType::Method as u8,
5514 JSJitInfo_AliasSet::AliasEverything as u8,
5515 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5516 false,
5517 false,
5518 false,
5519 false,
5520 false,
5521 false,
5522 0,
5523 ).to_ne_bytes()
5524 ),
5525});
5526}
5527unsafe extern "C" fn getUniform<D: DomTypes>
5528(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5529 let mut result = false;
5530 wrap_panic(&mut || result = (|| {
5531 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5532 let this = &*(this as *const D::WebGLRenderingContext);
5533 let args = &*args;
5534 let argc = args.argc_;
5535
5536 if argc < 2 {
5537 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getUniform\".");
5538 return false;
5539 }
5540 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5541 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5542 Ok(val) => val,
5543 Err(()) => {
5544 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
5545 return false;
5546
5547 }
5548 }
5549
5550 } else {
5551 throw_type_error(cx.raw_cx(), "Value is not an object.");
5552 return false;
5553
5554 };
5555 let arg1: DomRoot<D::WebGLUniformLocation> = if HandleValue::from_raw(args.get(1)).get().is_object() {
5556 match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
5557 Ok(val) => val,
5558 Err(()) => {
5559 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
5560 return false;
5561
5562 }
5563 }
5564
5565 } else {
5566 throw_type_error(cx.raw_cx(), "Value is not an object.");
5567 return false;
5568
5569 };
5570 rooted!(&in(cx) let mut retval: JSVal);
5571 let result: () = this.GetUniform(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, &arg1, retval.handle_mut());
5572
5573 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5574 return true;
5575 })());
5576 result
5577}
5578
5579
5580static getUniform_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5581
5582pub(crate) fn init_getUniform_methodinfo<D: DomTypes>() {
5583 getUniform_methodinfo.set(JSJitInfo {
5584 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5585 method: Some(getUniform::<D>)
5586 },
5587 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5588 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5589 },
5590 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5591 _bitfield_align_1: [],
5592 _bitfield_1: __BindgenBitfieldUnit::new(
5593 new_jsjitinfo_bitfield_1!(
5594 JSJitInfo_OpType::Method as u8,
5595 JSJitInfo_AliasSet::AliasEverything as u8,
5596 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5597 false,
5598 false,
5599 false,
5600 false,
5601 false,
5602 false,
5603 0,
5604 ).to_ne_bytes()
5605 ),
5606});
5607}
5608unsafe extern "C" fn getUniformLocation<D: DomTypes>
5609(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5610 let mut result = false;
5611 wrap_panic(&mut || result = (|| {
5612 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5613 let this = &*(this as *const D::WebGLRenderingContext);
5614 let args = &*args;
5615 let argc = args.argc_;
5616
5617 if argc < 2 {
5618 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getUniformLocation\".");
5619 return false;
5620 }
5621 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5622 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5623 Ok(val) => val,
5624 Err(()) => {
5625 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
5626 return false;
5627
5628 }
5629 }
5630
5631 } else {
5632 throw_type_error(cx.raw_cx(), "Value is not an object.");
5633 return false;
5634
5635 };
5636 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
5637 Ok(ConversionResult::Success(value)) => value,
5638 Ok(ConversionResult::Failure(error)) => {
5639 throw_type_error(cx.raw_cx(), &error);
5640 return false;
5641
5642 }
5643 _ => {
5644 return false;
5645
5646 },
5647 }
5648 ;
5649 let result: Option<DomRoot<D::WebGLUniformLocation>> = this.GetUniformLocation(&arg0, arg1);
5650
5651 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5652 return true;
5653 })());
5654 result
5655}
5656
5657
5658static getUniformLocation_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5659
5660pub(crate) fn init_getUniformLocation_methodinfo<D: DomTypes>() {
5661 getUniformLocation_methodinfo.set(JSJitInfo {
5662 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5663 method: Some(getUniformLocation::<D>)
5664 },
5665 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5666 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5667 },
5668 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5669 _bitfield_align_1: [],
5670 _bitfield_1: __BindgenBitfieldUnit::new(
5671 new_jsjitinfo_bitfield_1!(
5672 JSJitInfo_OpType::Method as u8,
5673 JSJitInfo_AliasSet::AliasEverything as u8,
5674 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5675 false,
5676 false,
5677 false,
5678 false,
5679 false,
5680 false,
5681 0,
5682 ).to_ne_bytes()
5683 ),
5684});
5685}
5686unsafe extern "C" fn getVertexAttrib<D: DomTypes>
5687(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5688 let mut result = false;
5689 wrap_panic(&mut || result = (|| {
5690 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5691 let this = &*(this as *const D::WebGLRenderingContext);
5692 let args = &*args;
5693 let argc = args.argc_;
5694
5695 if argc < 2 {
5696 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getVertexAttrib\".");
5697 return false;
5698 }
5699 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5700 Ok(ConversionResult::Success(value)) => value,
5701 Ok(ConversionResult::Failure(error)) => {
5702 throw_type_error(cx.raw_cx(), &error);
5703 return false;
5704
5705 }
5706 _ => {
5707 return false;
5708
5709 },
5710 }
5711 ;
5712 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5713 Ok(ConversionResult::Success(value)) => value,
5714 Ok(ConversionResult::Failure(error)) => {
5715 throw_type_error(cx.raw_cx(), &error);
5716 return false;
5717
5718 }
5719 _ => {
5720 return false;
5721
5722 },
5723 }
5724 ;
5725 rooted!(&in(cx) let mut retval: JSVal);
5726 let result: () = this.GetVertexAttrib(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, retval.handle_mut());
5727
5728 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5729 return true;
5730 })());
5731 result
5732}
5733
5734
5735static getVertexAttrib_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5736
5737pub(crate) fn init_getVertexAttrib_methodinfo<D: DomTypes>() {
5738 getVertexAttrib_methodinfo.set(JSJitInfo {
5739 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5740 method: Some(getVertexAttrib::<D>)
5741 },
5742 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5743 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5744 },
5745 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5746 _bitfield_align_1: [],
5747 _bitfield_1: __BindgenBitfieldUnit::new(
5748 new_jsjitinfo_bitfield_1!(
5749 JSJitInfo_OpType::Method as u8,
5750 JSJitInfo_AliasSet::AliasEverything as u8,
5751 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5752 false,
5753 false,
5754 false,
5755 false,
5756 false,
5757 false,
5758 0,
5759 ).to_ne_bytes()
5760 ),
5761});
5762}
5763unsafe extern "C" fn getVertexAttribOffset<D: DomTypes>
5764(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5765 let mut result = false;
5766 wrap_panic(&mut || result = (|| {
5767 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5768 let this = &*(this as *const D::WebGLRenderingContext);
5769 let args = &*args;
5770 let argc = args.argc_;
5771
5772 if argc < 2 {
5773 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.getVertexAttribOffset\".");
5774 return false;
5775 }
5776 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5777 Ok(ConversionResult::Success(value)) => value,
5778 Ok(ConversionResult::Failure(error)) => {
5779 throw_type_error(cx.raw_cx(), &error);
5780 return false;
5781
5782 }
5783 _ => {
5784 return false;
5785
5786 },
5787 }
5788 ;
5789 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5790 Ok(ConversionResult::Success(value)) => value,
5791 Ok(ConversionResult::Failure(error)) => {
5792 throw_type_error(cx.raw_cx(), &error);
5793 return false;
5794
5795 }
5796 _ => {
5797 return false;
5798
5799 },
5800 }
5801 ;
5802 let result: i64 = this.GetVertexAttribOffset(arg0, arg1);
5803
5804 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5805 return true;
5806 })());
5807 result
5808}
5809
5810
5811static getVertexAttribOffset_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5812
5813pub(crate) fn init_getVertexAttribOffset_methodinfo<D: DomTypes>() {
5814 getVertexAttribOffset_methodinfo.set(JSJitInfo {
5815 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5816 method: Some(getVertexAttribOffset::<D>)
5817 },
5818 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5819 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5820 },
5821 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5822 _bitfield_align_1: [],
5823 _bitfield_1: __BindgenBitfieldUnit::new(
5824 new_jsjitinfo_bitfield_1!(
5825 JSJitInfo_OpType::Method as u8,
5826 JSJitInfo_AliasSet::AliasEverything as u8,
5827 JSValueType::JSVAL_TYPE_DOUBLE as u8,
5828 false,
5829 false,
5830 false,
5831 false,
5832 false,
5833 false,
5834 0,
5835 ).to_ne_bytes()
5836 ),
5837});
5838}
5839unsafe extern "C" fn hint<D: DomTypes>
5840(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5841 let mut result = false;
5842 wrap_panic(&mut || result = (|| {
5843 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5844 let this = &*(this as *const D::WebGLRenderingContext);
5845 let args = &*args;
5846 let argc = args.argc_;
5847
5848 if argc < 2 {
5849 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.hint\".");
5850 return false;
5851 }
5852 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5853 Ok(ConversionResult::Success(value)) => value,
5854 Ok(ConversionResult::Failure(error)) => {
5855 throw_type_error(cx.raw_cx(), &error);
5856 return false;
5857
5858 }
5859 _ => {
5860 return false;
5861
5862 },
5863 }
5864 ;
5865 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
5866 Ok(ConversionResult::Success(value)) => value,
5867 Ok(ConversionResult::Failure(error)) => {
5868 throw_type_error(cx.raw_cx(), &error);
5869 return false;
5870
5871 }
5872 _ => {
5873 return false;
5874
5875 },
5876 }
5877 ;
5878 let result: () = this.Hint(arg0, arg1);
5879
5880 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5881 return true;
5882 })());
5883 result
5884}
5885
5886
5887static hint_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5888
5889pub(crate) fn init_hint_methodinfo<D: DomTypes>() {
5890 hint_methodinfo.set(JSJitInfo {
5891 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5892 method: Some(hint::<D>)
5893 },
5894 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5895 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5896 },
5897 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5898 _bitfield_align_1: [],
5899 _bitfield_1: __BindgenBitfieldUnit::new(
5900 new_jsjitinfo_bitfield_1!(
5901 JSJitInfo_OpType::Method as u8,
5902 JSJitInfo_AliasSet::AliasEverything as u8,
5903 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5904 false,
5905 false,
5906 false,
5907 false,
5908 false,
5909 false,
5910 0,
5911 ).to_ne_bytes()
5912 ),
5913});
5914}
5915unsafe extern "C" fn isBuffer<D: DomTypes>
5916(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5917 let mut result = false;
5918 wrap_panic(&mut || result = (|| {
5919 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5920 let this = &*(this as *const D::WebGLRenderingContext);
5921 let args = &*args;
5922 let argc = args.argc_;
5923
5924 if argc < 1 {
5925 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.isBuffer\".");
5926 return false;
5927 }
5928 let arg0: Option<DomRoot<D::WebGLBuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
5929 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
5930 Ok(val) => val,
5931 Err(()) => {
5932 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLBuffer.");
5933 return false;
5934
5935 }
5936 }
5937 )
5938 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
5939 None
5940 } else {
5941 throw_type_error(cx.raw_cx(), "Value is not an object.");
5942 return false;
5943
5944 };
5945 let result: bool = this.IsBuffer(arg0.as_deref());
5946
5947 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5948 return true;
5949 })());
5950 result
5951}
5952
5953
5954static isBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5955
5956pub(crate) fn init_isBuffer_methodinfo<D: DomTypes>() {
5957 isBuffer_methodinfo.set(JSJitInfo {
5958 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5959 method: Some(isBuffer::<D>)
5960 },
5961 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5962 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
5963 },
5964 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5965 _bitfield_align_1: [],
5966 _bitfield_1: __BindgenBitfieldUnit::new(
5967 new_jsjitinfo_bitfield_1!(
5968 JSJitInfo_OpType::Method as u8,
5969 JSJitInfo_AliasSet::AliasEverything as u8,
5970 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
5971 false,
5972 false,
5973 false,
5974 false,
5975 false,
5976 false,
5977 0,
5978 ).to_ne_bytes()
5979 ),
5980});
5981}
5982unsafe extern "C" fn isEnabled<D: DomTypes>
5983(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
5984 let mut result = false;
5985 wrap_panic(&mut || result = (|| {
5986 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5987 let this = &*(this as *const D::WebGLRenderingContext);
5988 let args = &*args;
5989 let argc = args.argc_;
5990
5991 if argc < 1 {
5992 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.isEnabled\".");
5993 return false;
5994 }
5995 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5996 Ok(ConversionResult::Success(value)) => value,
5997 Ok(ConversionResult::Failure(error)) => {
5998 throw_type_error(cx.raw_cx(), &error);
5999 return false;
6000
6001 }
6002 _ => {
6003 return false;
6004
6005 },
6006 }
6007 ;
6008 let result: bool = this.IsEnabled(arg0);
6009
6010 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6011 return true;
6012 })());
6013 result
6014}
6015
6016
6017static isEnabled_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6018
6019pub(crate) fn init_isEnabled_methodinfo<D: DomTypes>() {
6020 isEnabled_methodinfo.set(JSJitInfo {
6021 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6022 method: Some(isEnabled::<D>)
6023 },
6024 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6025 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6026 },
6027 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6028 _bitfield_align_1: [],
6029 _bitfield_1: __BindgenBitfieldUnit::new(
6030 new_jsjitinfo_bitfield_1!(
6031 JSJitInfo_OpType::Method as u8,
6032 JSJitInfo_AliasSet::AliasEverything as u8,
6033 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
6034 false,
6035 false,
6036 false,
6037 false,
6038 false,
6039 false,
6040 0,
6041 ).to_ne_bytes()
6042 ),
6043});
6044}
6045unsafe extern "C" fn isFramebuffer<D: DomTypes>
6046(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6047 let mut result = false;
6048 wrap_panic(&mut || result = (|| {
6049 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6050 let this = &*(this as *const D::WebGLRenderingContext);
6051 let args = &*args;
6052 let argc = args.argc_;
6053
6054 if argc < 1 {
6055 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.isFramebuffer\".");
6056 return false;
6057 }
6058 let arg0: Option<DomRoot<D::WebGLFramebuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6059 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6060 Ok(val) => val,
6061 Err(()) => {
6062 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLFramebuffer.");
6063 return false;
6064
6065 }
6066 }
6067 )
6068 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
6069 None
6070 } else {
6071 throw_type_error(cx.raw_cx(), "Value is not an object.");
6072 return false;
6073
6074 };
6075 let result: bool = this.IsFramebuffer(arg0.as_deref());
6076
6077 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6078 return true;
6079 })());
6080 result
6081}
6082
6083
6084static isFramebuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6085
6086pub(crate) fn init_isFramebuffer_methodinfo<D: DomTypes>() {
6087 isFramebuffer_methodinfo.set(JSJitInfo {
6088 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6089 method: Some(isFramebuffer::<D>)
6090 },
6091 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6092 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6093 },
6094 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6095 _bitfield_align_1: [],
6096 _bitfield_1: __BindgenBitfieldUnit::new(
6097 new_jsjitinfo_bitfield_1!(
6098 JSJitInfo_OpType::Method as u8,
6099 JSJitInfo_AliasSet::AliasEverything as u8,
6100 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
6101 false,
6102 false,
6103 false,
6104 false,
6105 false,
6106 false,
6107 0,
6108 ).to_ne_bytes()
6109 ),
6110});
6111}
6112unsafe extern "C" fn isProgram<D: DomTypes>
6113(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6114 let mut result = false;
6115 wrap_panic(&mut || result = (|| {
6116 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6117 let this = &*(this as *const D::WebGLRenderingContext);
6118 let args = &*args;
6119 let argc = args.argc_;
6120
6121 if argc < 1 {
6122 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.isProgram\".");
6123 return false;
6124 }
6125 let arg0: Option<DomRoot<D::WebGLProgram>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6126 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6127 Ok(val) => val,
6128 Err(()) => {
6129 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
6130 return false;
6131
6132 }
6133 }
6134 )
6135 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
6136 None
6137 } else {
6138 throw_type_error(cx.raw_cx(), "Value is not an object.");
6139 return false;
6140
6141 };
6142 let result: bool = this.IsProgram(arg0.as_deref());
6143
6144 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6145 return true;
6146 })());
6147 result
6148}
6149
6150
6151static isProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6152
6153pub(crate) fn init_isProgram_methodinfo<D: DomTypes>() {
6154 isProgram_methodinfo.set(JSJitInfo {
6155 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6156 method: Some(isProgram::<D>)
6157 },
6158 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6159 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6160 },
6161 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6162 _bitfield_align_1: [],
6163 _bitfield_1: __BindgenBitfieldUnit::new(
6164 new_jsjitinfo_bitfield_1!(
6165 JSJitInfo_OpType::Method as u8,
6166 JSJitInfo_AliasSet::AliasEverything as u8,
6167 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
6168 false,
6169 false,
6170 false,
6171 false,
6172 false,
6173 false,
6174 0,
6175 ).to_ne_bytes()
6176 ),
6177});
6178}
6179unsafe extern "C" fn isRenderbuffer<D: DomTypes>
6180(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6181 let mut result = false;
6182 wrap_panic(&mut || result = (|| {
6183 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6184 let this = &*(this as *const D::WebGLRenderingContext);
6185 let args = &*args;
6186 let argc = args.argc_;
6187
6188 if argc < 1 {
6189 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.isRenderbuffer\".");
6190 return false;
6191 }
6192 let arg0: Option<DomRoot<D::WebGLRenderbuffer>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6193 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6194 Ok(val) => val,
6195 Err(()) => {
6196 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLRenderbuffer.");
6197 return false;
6198
6199 }
6200 }
6201 )
6202 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
6203 None
6204 } else {
6205 throw_type_error(cx.raw_cx(), "Value is not an object.");
6206 return false;
6207
6208 };
6209 let result: bool = this.IsRenderbuffer(arg0.as_deref());
6210
6211 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6212 return true;
6213 })());
6214 result
6215}
6216
6217
6218static isRenderbuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6219
6220pub(crate) fn init_isRenderbuffer_methodinfo<D: DomTypes>() {
6221 isRenderbuffer_methodinfo.set(JSJitInfo {
6222 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6223 method: Some(isRenderbuffer::<D>)
6224 },
6225 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6226 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6227 },
6228 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6229 _bitfield_align_1: [],
6230 _bitfield_1: __BindgenBitfieldUnit::new(
6231 new_jsjitinfo_bitfield_1!(
6232 JSJitInfo_OpType::Method as u8,
6233 JSJitInfo_AliasSet::AliasEverything as u8,
6234 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
6235 false,
6236 false,
6237 false,
6238 false,
6239 false,
6240 false,
6241 0,
6242 ).to_ne_bytes()
6243 ),
6244});
6245}
6246unsafe extern "C" fn isShader<D: DomTypes>
6247(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6248 let mut result = false;
6249 wrap_panic(&mut || result = (|| {
6250 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6251 let this = &*(this as *const D::WebGLRenderingContext);
6252 let args = &*args;
6253 let argc = args.argc_;
6254
6255 if argc < 1 {
6256 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.isShader\".");
6257 return false;
6258 }
6259 let arg0: Option<DomRoot<D::WebGLShader>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6260 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6261 Ok(val) => val,
6262 Err(()) => {
6263 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
6264 return false;
6265
6266 }
6267 }
6268 )
6269 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
6270 None
6271 } else {
6272 throw_type_error(cx.raw_cx(), "Value is not an object.");
6273 return false;
6274
6275 };
6276 let result: bool = this.IsShader(arg0.as_deref());
6277
6278 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6279 return true;
6280 })());
6281 result
6282}
6283
6284
6285static isShader_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6286
6287pub(crate) fn init_isShader_methodinfo<D: DomTypes>() {
6288 isShader_methodinfo.set(JSJitInfo {
6289 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6290 method: Some(isShader::<D>)
6291 },
6292 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6293 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6294 },
6295 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6296 _bitfield_align_1: [],
6297 _bitfield_1: __BindgenBitfieldUnit::new(
6298 new_jsjitinfo_bitfield_1!(
6299 JSJitInfo_OpType::Method as u8,
6300 JSJitInfo_AliasSet::AliasEverything as u8,
6301 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
6302 false,
6303 false,
6304 false,
6305 false,
6306 false,
6307 false,
6308 0,
6309 ).to_ne_bytes()
6310 ),
6311});
6312}
6313unsafe extern "C" fn isTexture<D: DomTypes>
6314(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6315 let mut result = false;
6316 wrap_panic(&mut || result = (|| {
6317 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6318 let this = &*(this as *const D::WebGLRenderingContext);
6319 let args = &*args;
6320 let argc = args.argc_;
6321
6322 if argc < 1 {
6323 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.isTexture\".");
6324 return false;
6325 }
6326 let arg0: Option<DomRoot<D::WebGLTexture>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6327 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6328 Ok(val) => val,
6329 Err(()) => {
6330 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLTexture.");
6331 return false;
6332
6333 }
6334 }
6335 )
6336 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
6337 None
6338 } else {
6339 throw_type_error(cx.raw_cx(), "Value is not an object.");
6340 return false;
6341
6342 };
6343 let result: bool = this.IsTexture(arg0.as_deref());
6344
6345 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6346 return true;
6347 })());
6348 result
6349}
6350
6351
6352static isTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6353
6354pub(crate) fn init_isTexture_methodinfo<D: DomTypes>() {
6355 isTexture_methodinfo.set(JSJitInfo {
6356 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6357 method: Some(isTexture::<D>)
6358 },
6359 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6360 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6361 },
6362 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6363 _bitfield_align_1: [],
6364 _bitfield_1: __BindgenBitfieldUnit::new(
6365 new_jsjitinfo_bitfield_1!(
6366 JSJitInfo_OpType::Method as u8,
6367 JSJitInfo_AliasSet::AliasEverything as u8,
6368 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
6369 false,
6370 false,
6371 false,
6372 false,
6373 false,
6374 false,
6375 0,
6376 ).to_ne_bytes()
6377 ),
6378});
6379}
6380unsafe extern "C" fn lineWidth<D: DomTypes>
6381(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6382 let mut result = false;
6383 wrap_panic(&mut || result = (|| {
6384 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6385 let this = &*(this as *const D::WebGLRenderingContext);
6386 let args = &*args;
6387 let argc = args.argc_;
6388
6389 if argc < 1 {
6390 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.lineWidth\".");
6391 return false;
6392 }
6393 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6394 Ok(ConversionResult::Success(value)) => value,
6395 Ok(ConversionResult::Failure(error)) => {
6396 throw_type_error(cx.raw_cx(), &error);
6397 return false;
6398
6399 }
6400 _ => {
6401 return false;
6402
6403 },
6404 }
6405 ;
6406 let result: () = this.LineWidth(arg0);
6407
6408 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6409 return true;
6410 })());
6411 result
6412}
6413
6414
6415static lineWidth_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6416
6417pub(crate) fn init_lineWidth_methodinfo<D: DomTypes>() {
6418 lineWidth_methodinfo.set(JSJitInfo {
6419 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6420 method: Some(lineWidth::<D>)
6421 },
6422 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6423 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6424 },
6425 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6426 _bitfield_align_1: [],
6427 _bitfield_1: __BindgenBitfieldUnit::new(
6428 new_jsjitinfo_bitfield_1!(
6429 JSJitInfo_OpType::Method as u8,
6430 JSJitInfo_AliasSet::AliasEverything as u8,
6431 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6432 false,
6433 false,
6434 false,
6435 false,
6436 false,
6437 false,
6438 0,
6439 ).to_ne_bytes()
6440 ),
6441});
6442}
6443unsafe extern "C" fn linkProgram<D: DomTypes>
6444(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6445 let mut result = false;
6446 wrap_panic(&mut || result = (|| {
6447 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6448 let this = &*(this as *const D::WebGLRenderingContext);
6449 let args = &*args;
6450 let argc = args.argc_;
6451
6452 if argc < 1 {
6453 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.linkProgram\".");
6454 return false;
6455 }
6456 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6457 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6458 Ok(val) => val,
6459 Err(()) => {
6460 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
6461 return false;
6462
6463 }
6464 }
6465
6466 } else {
6467 throw_type_error(cx.raw_cx(), "Value is not an object.");
6468 return false;
6469
6470 };
6471 let result: () = this.LinkProgram(&arg0);
6472
6473 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6474 return true;
6475 })());
6476 result
6477}
6478
6479
6480static linkProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6481
6482pub(crate) fn init_linkProgram_methodinfo<D: DomTypes>() {
6483 linkProgram_methodinfo.set(JSJitInfo {
6484 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6485 method: Some(linkProgram::<D>)
6486 },
6487 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6488 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6489 },
6490 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6491 _bitfield_align_1: [],
6492 _bitfield_1: __BindgenBitfieldUnit::new(
6493 new_jsjitinfo_bitfield_1!(
6494 JSJitInfo_OpType::Method as u8,
6495 JSJitInfo_AliasSet::AliasEverything as u8,
6496 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6497 false,
6498 false,
6499 false,
6500 false,
6501 false,
6502 false,
6503 0,
6504 ).to_ne_bytes()
6505 ),
6506});
6507}
6508unsafe extern "C" fn pixelStorei<D: DomTypes>
6509(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6510 let mut result = false;
6511 wrap_panic(&mut || result = (|| {
6512 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6513 let this = &*(this as *const D::WebGLRenderingContext);
6514 let args = &*args;
6515 let argc = args.argc_;
6516
6517 if argc < 2 {
6518 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.pixelStorei\".");
6519 return false;
6520 }
6521 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6522 Ok(ConversionResult::Success(value)) => value,
6523 Ok(ConversionResult::Failure(error)) => {
6524 throw_type_error(cx.raw_cx(), &error);
6525 return false;
6526
6527 }
6528 _ => {
6529 return false;
6530
6531 },
6532 }
6533 ;
6534 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
6535 Ok(ConversionResult::Success(value)) => value,
6536 Ok(ConversionResult::Failure(error)) => {
6537 throw_type_error(cx.raw_cx(), &error);
6538 return false;
6539
6540 }
6541 _ => {
6542 return false;
6543
6544 },
6545 }
6546 ;
6547 let result: () = this.PixelStorei(arg0, arg1);
6548
6549 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6550 return true;
6551 })());
6552 result
6553}
6554
6555
6556static pixelStorei_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6557
6558pub(crate) fn init_pixelStorei_methodinfo<D: DomTypes>() {
6559 pixelStorei_methodinfo.set(JSJitInfo {
6560 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6561 method: Some(pixelStorei::<D>)
6562 },
6563 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6564 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6565 },
6566 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6567 _bitfield_align_1: [],
6568 _bitfield_1: __BindgenBitfieldUnit::new(
6569 new_jsjitinfo_bitfield_1!(
6570 JSJitInfo_OpType::Method as u8,
6571 JSJitInfo_AliasSet::AliasEverything as u8,
6572 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6573 false,
6574 false,
6575 false,
6576 false,
6577 false,
6578 false,
6579 0,
6580 ).to_ne_bytes()
6581 ),
6582});
6583}
6584unsafe extern "C" fn polygonOffset<D: DomTypes>
6585(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6586 let mut result = false;
6587 wrap_panic(&mut || result = (|| {
6588 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6589 let this = &*(this as *const D::WebGLRenderingContext);
6590 let args = &*args;
6591 let argc = args.argc_;
6592
6593 if argc < 2 {
6594 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.polygonOffset\".");
6595 return false;
6596 }
6597 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6598 Ok(ConversionResult::Success(value)) => value,
6599 Ok(ConversionResult::Failure(error)) => {
6600 throw_type_error(cx.raw_cx(), &error);
6601 return false;
6602
6603 }
6604 _ => {
6605 return false;
6606
6607 },
6608 }
6609 ;
6610 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
6611 Ok(ConversionResult::Success(value)) => value,
6612 Ok(ConversionResult::Failure(error)) => {
6613 throw_type_error(cx.raw_cx(), &error);
6614 return false;
6615
6616 }
6617 _ => {
6618 return false;
6619
6620 },
6621 }
6622 ;
6623 let result: () = this.PolygonOffset(arg0, arg1);
6624
6625 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6626 return true;
6627 })());
6628 result
6629}
6630
6631
6632static polygonOffset_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6633
6634pub(crate) fn init_polygonOffset_methodinfo<D: DomTypes>() {
6635 polygonOffset_methodinfo.set(JSJitInfo {
6636 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6637 method: Some(polygonOffset::<D>)
6638 },
6639 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6640 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6641 },
6642 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6643 _bitfield_align_1: [],
6644 _bitfield_1: __BindgenBitfieldUnit::new(
6645 new_jsjitinfo_bitfield_1!(
6646 JSJitInfo_OpType::Method as u8,
6647 JSJitInfo_AliasSet::AliasEverything as u8,
6648 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6649 false,
6650 false,
6651 false,
6652 false,
6653 false,
6654 false,
6655 0,
6656 ).to_ne_bytes()
6657 ),
6658});
6659}
6660unsafe extern "C" fn renderbufferStorage<D: DomTypes>
6661(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6662 let mut result = false;
6663 wrap_panic(&mut || result = (|| {
6664 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6665 let this = &*(this as *const D::WebGLRenderingContext);
6666 let args = &*args;
6667 let argc = args.argc_;
6668
6669 if argc < 4 {
6670 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.renderbufferStorage\".");
6671 return false;
6672 }
6673 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6674 Ok(ConversionResult::Success(value)) => value,
6675 Ok(ConversionResult::Failure(error)) => {
6676 throw_type_error(cx.raw_cx(), &error);
6677 return false;
6678
6679 }
6680 _ => {
6681 return false;
6682
6683 },
6684 }
6685 ;
6686 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
6687 Ok(ConversionResult::Success(value)) => value,
6688 Ok(ConversionResult::Failure(error)) => {
6689 throw_type_error(cx.raw_cx(), &error);
6690 return false;
6691
6692 }
6693 _ => {
6694 return false;
6695
6696 },
6697 }
6698 ;
6699 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
6700 Ok(ConversionResult::Success(value)) => value,
6701 Ok(ConversionResult::Failure(error)) => {
6702 throw_type_error(cx.raw_cx(), &error);
6703 return false;
6704
6705 }
6706 _ => {
6707 return false;
6708
6709 },
6710 }
6711 ;
6712 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
6713 Ok(ConversionResult::Success(value)) => value,
6714 Ok(ConversionResult::Failure(error)) => {
6715 throw_type_error(cx.raw_cx(), &error);
6716 return false;
6717
6718 }
6719 _ => {
6720 return false;
6721
6722 },
6723 }
6724 ;
6725 let result: () = this.RenderbufferStorage(arg0, arg1, arg2, arg3);
6726
6727 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6728 return true;
6729 })());
6730 result
6731}
6732
6733
6734static renderbufferStorage_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6735
6736pub(crate) fn init_renderbufferStorage_methodinfo<D: DomTypes>() {
6737 renderbufferStorage_methodinfo.set(JSJitInfo {
6738 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6739 method: Some(renderbufferStorage::<D>)
6740 },
6741 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6742 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6743 },
6744 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6745 _bitfield_align_1: [],
6746 _bitfield_1: __BindgenBitfieldUnit::new(
6747 new_jsjitinfo_bitfield_1!(
6748 JSJitInfo_OpType::Method as u8,
6749 JSJitInfo_AliasSet::AliasEverything as u8,
6750 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6751 false,
6752 false,
6753 false,
6754 false,
6755 false,
6756 false,
6757 0,
6758 ).to_ne_bytes()
6759 ),
6760});
6761}
6762unsafe extern "C" fn sampleCoverage<D: DomTypes>
6763(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6764 let mut result = false;
6765 wrap_panic(&mut || result = (|| {
6766 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6767 let this = &*(this as *const D::WebGLRenderingContext);
6768 let args = &*args;
6769 let argc = args.argc_;
6770
6771 if argc < 2 {
6772 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.sampleCoverage\".");
6773 return false;
6774 }
6775 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6776 Ok(ConversionResult::Success(value)) => value,
6777 Ok(ConversionResult::Failure(error)) => {
6778 throw_type_error(cx.raw_cx(), &error);
6779 return false;
6780
6781 }
6782 _ => {
6783 return false;
6784
6785 },
6786 }
6787 ;
6788 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
6789 Ok(ConversionResult::Success(value)) => value,
6790 Ok(ConversionResult::Failure(error)) => {
6791 throw_type_error(cx.raw_cx(), &error);
6792 return false;
6793
6794 }
6795 _ => {
6796 return false;
6797
6798 },
6799 }
6800 ;
6801 let result: () = this.SampleCoverage(arg0, arg1);
6802
6803 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6804 return true;
6805 })());
6806 result
6807}
6808
6809
6810static sampleCoverage_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6811
6812pub(crate) fn init_sampleCoverage_methodinfo<D: DomTypes>() {
6813 sampleCoverage_methodinfo.set(JSJitInfo {
6814 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6815 method: Some(sampleCoverage::<D>)
6816 },
6817 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6818 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6819 },
6820 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6821 _bitfield_align_1: [],
6822 _bitfield_1: __BindgenBitfieldUnit::new(
6823 new_jsjitinfo_bitfield_1!(
6824 JSJitInfo_OpType::Method as u8,
6825 JSJitInfo_AliasSet::AliasEverything as u8,
6826 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6827 false,
6828 false,
6829 false,
6830 false,
6831 false,
6832 false,
6833 0,
6834 ).to_ne_bytes()
6835 ),
6836});
6837}
6838unsafe extern "C" fn scissor<D: DomTypes>
6839(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6840 let mut result = false;
6841 wrap_panic(&mut || result = (|| {
6842 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6843 let this = &*(this as *const D::WebGLRenderingContext);
6844 let args = &*args;
6845 let argc = args.argc_;
6846
6847 if argc < 4 {
6848 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.scissor\".");
6849 return false;
6850 }
6851 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6852 Ok(ConversionResult::Success(value)) => value,
6853 Ok(ConversionResult::Failure(error)) => {
6854 throw_type_error(cx.raw_cx(), &error);
6855 return false;
6856
6857 }
6858 _ => {
6859 return false;
6860
6861 },
6862 }
6863 ;
6864 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
6865 Ok(ConversionResult::Success(value)) => value,
6866 Ok(ConversionResult::Failure(error)) => {
6867 throw_type_error(cx.raw_cx(), &error);
6868 return false;
6869
6870 }
6871 _ => {
6872 return false;
6873
6874 },
6875 }
6876 ;
6877 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
6878 Ok(ConversionResult::Success(value)) => value,
6879 Ok(ConversionResult::Failure(error)) => {
6880 throw_type_error(cx.raw_cx(), &error);
6881 return false;
6882
6883 }
6884 _ => {
6885 return false;
6886
6887 },
6888 }
6889 ;
6890 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), 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 result: () = this.Scissor(arg0, arg1, arg2, arg3);
6904
6905 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6906 return true;
6907 })());
6908 result
6909}
6910
6911
6912static scissor_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6913
6914pub(crate) fn init_scissor_methodinfo<D: DomTypes>() {
6915 scissor_methodinfo.set(JSJitInfo {
6916 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6917 method: Some(scissor::<D>)
6918 },
6919 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6920 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6921 },
6922 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6923 _bitfield_align_1: [],
6924 _bitfield_1: __BindgenBitfieldUnit::new(
6925 new_jsjitinfo_bitfield_1!(
6926 JSJitInfo_OpType::Method as u8,
6927 JSJitInfo_AliasSet::AliasEverything as u8,
6928 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6929 false,
6930 false,
6931 false,
6932 false,
6933 false,
6934 false,
6935 0,
6936 ).to_ne_bytes()
6937 ),
6938});
6939}
6940unsafe extern "C" fn shaderSource<D: DomTypes>
6941(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
6942 let mut result = false;
6943 wrap_panic(&mut || result = (|| {
6944 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6945 let this = &*(this as *const D::WebGLRenderingContext);
6946 let args = &*args;
6947 let argc = args.argc_;
6948
6949 if argc < 2 {
6950 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.shaderSource\".");
6951 return false;
6952 }
6953 let arg0: DomRoot<D::WebGLShader> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6954 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6955 Ok(val) => val,
6956 Err(()) => {
6957 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLShader.");
6958 return false;
6959
6960 }
6961 }
6962
6963 } else {
6964 throw_type_error(cx.raw_cx(), "Value is not an object.");
6965 return false;
6966
6967 };
6968 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
6969 Ok(ConversionResult::Success(value)) => value,
6970 Ok(ConversionResult::Failure(error)) => {
6971 throw_type_error(cx.raw_cx(), &error);
6972 return false;
6973
6974 }
6975 _ => {
6976 return false;
6977
6978 },
6979 }
6980 ;
6981 let result: () = this.ShaderSource(&arg0, arg1);
6982
6983 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6984 return true;
6985 })());
6986 result
6987}
6988
6989
6990static shaderSource_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6991
6992pub(crate) fn init_shaderSource_methodinfo<D: DomTypes>() {
6993 shaderSource_methodinfo.set(JSJitInfo {
6994 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6995 method: Some(shaderSource::<D>)
6996 },
6997 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6998 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
6999 },
7000 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7001 _bitfield_align_1: [],
7002 _bitfield_1: __BindgenBitfieldUnit::new(
7003 new_jsjitinfo_bitfield_1!(
7004 JSJitInfo_OpType::Method as u8,
7005 JSJitInfo_AliasSet::AliasEverything as u8,
7006 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7007 false,
7008 false,
7009 false,
7010 false,
7011 false,
7012 false,
7013 0,
7014 ).to_ne_bytes()
7015 ),
7016});
7017}
7018unsafe extern "C" fn stencilFunc<D: DomTypes>
7019(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7020 let mut result = false;
7021 wrap_panic(&mut || result = (|| {
7022 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7023 let this = &*(this as *const D::WebGLRenderingContext);
7024 let args = &*args;
7025 let argc = args.argc_;
7026
7027 if argc < 3 {
7028 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.stencilFunc\".");
7029 return false;
7030 }
7031 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7032 Ok(ConversionResult::Success(value)) => value,
7033 Ok(ConversionResult::Failure(error)) => {
7034 throw_type_error(cx.raw_cx(), &error);
7035 return false;
7036
7037 }
7038 _ => {
7039 return false;
7040
7041 },
7042 }
7043 ;
7044 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7045 Ok(ConversionResult::Success(value)) => value,
7046 Ok(ConversionResult::Failure(error)) => {
7047 throw_type_error(cx.raw_cx(), &error);
7048 return false;
7049
7050 }
7051 _ => {
7052 return false;
7053
7054 },
7055 }
7056 ;
7057 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7058 Ok(ConversionResult::Success(value)) => value,
7059 Ok(ConversionResult::Failure(error)) => {
7060 throw_type_error(cx.raw_cx(), &error);
7061 return false;
7062
7063 }
7064 _ => {
7065 return false;
7066
7067 },
7068 }
7069 ;
7070 let result: () = this.StencilFunc(arg0, arg1, arg2);
7071
7072 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7073 return true;
7074 })());
7075 result
7076}
7077
7078
7079static stencilFunc_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7080
7081pub(crate) fn init_stencilFunc_methodinfo<D: DomTypes>() {
7082 stencilFunc_methodinfo.set(JSJitInfo {
7083 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7084 method: Some(stencilFunc::<D>)
7085 },
7086 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7087 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7088 },
7089 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7090 _bitfield_align_1: [],
7091 _bitfield_1: __BindgenBitfieldUnit::new(
7092 new_jsjitinfo_bitfield_1!(
7093 JSJitInfo_OpType::Method as u8,
7094 JSJitInfo_AliasSet::AliasEverything as u8,
7095 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7096 false,
7097 false,
7098 false,
7099 false,
7100 false,
7101 false,
7102 0,
7103 ).to_ne_bytes()
7104 ),
7105});
7106}
7107unsafe extern "C" fn stencilFuncSeparate<D: DomTypes>
7108(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7109 let mut result = false;
7110 wrap_panic(&mut || result = (|| {
7111 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7112 let this = &*(this as *const D::WebGLRenderingContext);
7113 let args = &*args;
7114 let argc = args.argc_;
7115
7116 if argc < 4 {
7117 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.stencilFuncSeparate\".");
7118 return false;
7119 }
7120 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7121 Ok(ConversionResult::Success(value)) => value,
7122 Ok(ConversionResult::Failure(error)) => {
7123 throw_type_error(cx.raw_cx(), &error);
7124 return false;
7125
7126 }
7127 _ => {
7128 return false;
7129
7130 },
7131 }
7132 ;
7133 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7134 Ok(ConversionResult::Success(value)) => value,
7135 Ok(ConversionResult::Failure(error)) => {
7136 throw_type_error(cx.raw_cx(), &error);
7137 return false;
7138
7139 }
7140 _ => {
7141 return false;
7142
7143 },
7144 }
7145 ;
7146 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7147 Ok(ConversionResult::Success(value)) => value,
7148 Ok(ConversionResult::Failure(error)) => {
7149 throw_type_error(cx.raw_cx(), &error);
7150 return false;
7151
7152 }
7153 _ => {
7154 return false;
7155
7156 },
7157 }
7158 ;
7159 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
7160 Ok(ConversionResult::Success(value)) => value,
7161 Ok(ConversionResult::Failure(error)) => {
7162 throw_type_error(cx.raw_cx(), &error);
7163 return false;
7164
7165 }
7166 _ => {
7167 return false;
7168
7169 },
7170 }
7171 ;
7172 let result: () = this.StencilFuncSeparate(arg0, arg1, arg2, arg3);
7173
7174 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7175 return true;
7176 })());
7177 result
7178}
7179
7180
7181static stencilFuncSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7182
7183pub(crate) fn init_stencilFuncSeparate_methodinfo<D: DomTypes>() {
7184 stencilFuncSeparate_methodinfo.set(JSJitInfo {
7185 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7186 method: Some(stencilFuncSeparate::<D>)
7187 },
7188 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7189 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7190 },
7191 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7192 _bitfield_align_1: [],
7193 _bitfield_1: __BindgenBitfieldUnit::new(
7194 new_jsjitinfo_bitfield_1!(
7195 JSJitInfo_OpType::Method as u8,
7196 JSJitInfo_AliasSet::AliasEverything as u8,
7197 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7198 false,
7199 false,
7200 false,
7201 false,
7202 false,
7203 false,
7204 0,
7205 ).to_ne_bytes()
7206 ),
7207});
7208}
7209unsafe extern "C" fn stencilMask<D: DomTypes>
7210(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7211 let mut result = false;
7212 wrap_panic(&mut || result = (|| {
7213 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7214 let this = &*(this as *const D::WebGLRenderingContext);
7215 let args = &*args;
7216 let argc = args.argc_;
7217
7218 if argc < 1 {
7219 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.stencilMask\".");
7220 return false;
7221 }
7222 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7223 Ok(ConversionResult::Success(value)) => value,
7224 Ok(ConversionResult::Failure(error)) => {
7225 throw_type_error(cx.raw_cx(), &error);
7226 return false;
7227
7228 }
7229 _ => {
7230 return false;
7231
7232 },
7233 }
7234 ;
7235 let result: () = this.StencilMask(arg0);
7236
7237 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7238 return true;
7239 })());
7240 result
7241}
7242
7243
7244static stencilMask_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7245
7246pub(crate) fn init_stencilMask_methodinfo<D: DomTypes>() {
7247 stencilMask_methodinfo.set(JSJitInfo {
7248 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7249 method: Some(stencilMask::<D>)
7250 },
7251 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7252 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7253 },
7254 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7255 _bitfield_align_1: [],
7256 _bitfield_1: __BindgenBitfieldUnit::new(
7257 new_jsjitinfo_bitfield_1!(
7258 JSJitInfo_OpType::Method as u8,
7259 JSJitInfo_AliasSet::AliasEverything as u8,
7260 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7261 false,
7262 false,
7263 false,
7264 false,
7265 false,
7266 false,
7267 0,
7268 ).to_ne_bytes()
7269 ),
7270});
7271}
7272unsafe extern "C" fn stencilMaskSeparate<D: DomTypes>
7273(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7274 let mut result = false;
7275 wrap_panic(&mut || result = (|| {
7276 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7277 let this = &*(this as *const D::WebGLRenderingContext);
7278 let args = &*args;
7279 let argc = args.argc_;
7280
7281 if argc < 2 {
7282 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.stencilMaskSeparate\".");
7283 return false;
7284 }
7285 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7286 Ok(ConversionResult::Success(value)) => value,
7287 Ok(ConversionResult::Failure(error)) => {
7288 throw_type_error(cx.raw_cx(), &error);
7289 return false;
7290
7291 }
7292 _ => {
7293 return false;
7294
7295 },
7296 }
7297 ;
7298 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7299 Ok(ConversionResult::Success(value)) => value,
7300 Ok(ConversionResult::Failure(error)) => {
7301 throw_type_error(cx.raw_cx(), &error);
7302 return false;
7303
7304 }
7305 _ => {
7306 return false;
7307
7308 },
7309 }
7310 ;
7311 let result: () = this.StencilMaskSeparate(arg0, arg1);
7312
7313 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7314 return true;
7315 })());
7316 result
7317}
7318
7319
7320static stencilMaskSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7321
7322pub(crate) fn init_stencilMaskSeparate_methodinfo<D: DomTypes>() {
7323 stencilMaskSeparate_methodinfo.set(JSJitInfo {
7324 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7325 method: Some(stencilMaskSeparate::<D>)
7326 },
7327 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7328 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7329 },
7330 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7331 _bitfield_align_1: [],
7332 _bitfield_1: __BindgenBitfieldUnit::new(
7333 new_jsjitinfo_bitfield_1!(
7334 JSJitInfo_OpType::Method as u8,
7335 JSJitInfo_AliasSet::AliasEverything as u8,
7336 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7337 false,
7338 false,
7339 false,
7340 false,
7341 false,
7342 false,
7343 0,
7344 ).to_ne_bytes()
7345 ),
7346});
7347}
7348unsafe extern "C" fn stencilOp<D: DomTypes>
7349(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7350 let mut result = false;
7351 wrap_panic(&mut || result = (|| {
7352 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7353 let this = &*(this as *const D::WebGLRenderingContext);
7354 let args = &*args;
7355 let argc = args.argc_;
7356
7357 if argc < 3 {
7358 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.stencilOp\".");
7359 return false;
7360 }
7361 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7362 Ok(ConversionResult::Success(value)) => value,
7363 Ok(ConversionResult::Failure(error)) => {
7364 throw_type_error(cx.raw_cx(), &error);
7365 return false;
7366
7367 }
7368 _ => {
7369 return false;
7370
7371 },
7372 }
7373 ;
7374 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7375 Ok(ConversionResult::Success(value)) => value,
7376 Ok(ConversionResult::Failure(error)) => {
7377 throw_type_error(cx.raw_cx(), &error);
7378 return false;
7379
7380 }
7381 _ => {
7382 return false;
7383
7384 },
7385 }
7386 ;
7387 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7388 Ok(ConversionResult::Success(value)) => value,
7389 Ok(ConversionResult::Failure(error)) => {
7390 throw_type_error(cx.raw_cx(), &error);
7391 return false;
7392
7393 }
7394 _ => {
7395 return false;
7396
7397 },
7398 }
7399 ;
7400 let result: () = this.StencilOp(arg0, arg1, arg2);
7401
7402 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7403 return true;
7404 })());
7405 result
7406}
7407
7408
7409static stencilOp_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7410
7411pub(crate) fn init_stencilOp_methodinfo<D: DomTypes>() {
7412 stencilOp_methodinfo.set(JSJitInfo {
7413 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7414 method: Some(stencilOp::<D>)
7415 },
7416 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7417 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7418 },
7419 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7420 _bitfield_align_1: [],
7421 _bitfield_1: __BindgenBitfieldUnit::new(
7422 new_jsjitinfo_bitfield_1!(
7423 JSJitInfo_OpType::Method as u8,
7424 JSJitInfo_AliasSet::AliasEverything as u8,
7425 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7426 false,
7427 false,
7428 false,
7429 false,
7430 false,
7431 false,
7432 0,
7433 ).to_ne_bytes()
7434 ),
7435});
7436}
7437unsafe extern "C" fn stencilOpSeparate<D: DomTypes>
7438(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7439 let mut result = false;
7440 wrap_panic(&mut || result = (|| {
7441 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7442 let this = &*(this as *const D::WebGLRenderingContext);
7443 let args = &*args;
7444 let argc = args.argc_;
7445
7446 if argc < 4 {
7447 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.stencilOpSeparate\".");
7448 return false;
7449 }
7450 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7451 Ok(ConversionResult::Success(value)) => value,
7452 Ok(ConversionResult::Failure(error)) => {
7453 throw_type_error(cx.raw_cx(), &error);
7454 return false;
7455
7456 }
7457 _ => {
7458 return false;
7459
7460 },
7461 }
7462 ;
7463 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7464 Ok(ConversionResult::Success(value)) => value,
7465 Ok(ConversionResult::Failure(error)) => {
7466 throw_type_error(cx.raw_cx(), &error);
7467 return false;
7468
7469 }
7470 _ => {
7471 return false;
7472
7473 },
7474 }
7475 ;
7476 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7477 Ok(ConversionResult::Success(value)) => value,
7478 Ok(ConversionResult::Failure(error)) => {
7479 throw_type_error(cx.raw_cx(), &error);
7480 return false;
7481
7482 }
7483 _ => {
7484 return false;
7485
7486 },
7487 }
7488 ;
7489 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
7490 Ok(ConversionResult::Success(value)) => value,
7491 Ok(ConversionResult::Failure(error)) => {
7492 throw_type_error(cx.raw_cx(), &error);
7493 return false;
7494
7495 }
7496 _ => {
7497 return false;
7498
7499 },
7500 }
7501 ;
7502 let result: () = this.StencilOpSeparate(arg0, arg1, arg2, arg3);
7503
7504 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7505 return true;
7506 })());
7507 result
7508}
7509
7510
7511static stencilOpSeparate_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7512
7513pub(crate) fn init_stencilOpSeparate_methodinfo<D: DomTypes>() {
7514 stencilOpSeparate_methodinfo.set(JSJitInfo {
7515 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7516 method: Some(stencilOpSeparate::<D>)
7517 },
7518 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7519 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7520 },
7521 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7522 _bitfield_align_1: [],
7523 _bitfield_1: __BindgenBitfieldUnit::new(
7524 new_jsjitinfo_bitfield_1!(
7525 JSJitInfo_OpType::Method as u8,
7526 JSJitInfo_AliasSet::AliasEverything as u8,
7527 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7528 false,
7529 false,
7530 false,
7531 false,
7532 false,
7533 false,
7534 0,
7535 ).to_ne_bytes()
7536 ),
7537});
7538}
7539unsafe extern "C" fn texParameterf<D: DomTypes>
7540(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7541 let mut result = false;
7542 wrap_panic(&mut || result = (|| {
7543 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7544 let this = &*(this as *const D::WebGLRenderingContext);
7545 let args = &*args;
7546 let argc = args.argc_;
7547
7548 if argc < 3 {
7549 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.texParameterf\".");
7550 return false;
7551 }
7552 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7553 Ok(ConversionResult::Success(value)) => value,
7554 Ok(ConversionResult::Failure(error)) => {
7555 throw_type_error(cx.raw_cx(), &error);
7556 return false;
7557
7558 }
7559 _ => {
7560 return false;
7561
7562 },
7563 }
7564 ;
7565 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7566 Ok(ConversionResult::Success(value)) => value,
7567 Ok(ConversionResult::Failure(error)) => {
7568 throw_type_error(cx.raw_cx(), &error);
7569 return false;
7570
7571 }
7572 _ => {
7573 return false;
7574
7575 },
7576 }
7577 ;
7578 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
7579 Ok(ConversionResult::Success(value)) => value,
7580 Ok(ConversionResult::Failure(error)) => {
7581 throw_type_error(cx.raw_cx(), &error);
7582 return false;
7583
7584 }
7585 _ => {
7586 return false;
7587
7588 },
7589 }
7590 ;
7591 let result: () = this.TexParameterf(arg0, arg1, arg2);
7592
7593 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7594 return true;
7595 })());
7596 result
7597}
7598
7599
7600static texParameterf_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7601
7602pub(crate) fn init_texParameterf_methodinfo<D: DomTypes>() {
7603 texParameterf_methodinfo.set(JSJitInfo {
7604 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7605 method: Some(texParameterf::<D>)
7606 },
7607 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7608 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7609 },
7610 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7611 _bitfield_align_1: [],
7612 _bitfield_1: __BindgenBitfieldUnit::new(
7613 new_jsjitinfo_bitfield_1!(
7614 JSJitInfo_OpType::Method as u8,
7615 JSJitInfo_AliasSet::AliasEverything as u8,
7616 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7617 false,
7618 false,
7619 false,
7620 false,
7621 false,
7622 false,
7623 0,
7624 ).to_ne_bytes()
7625 ),
7626});
7627}
7628unsafe extern "C" fn texParameteri<D: DomTypes>
7629(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7630 let mut result = false;
7631 wrap_panic(&mut || result = (|| {
7632 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7633 let this = &*(this as *const D::WebGLRenderingContext);
7634 let args = &*args;
7635 let argc = args.argc_;
7636
7637 if argc < 3 {
7638 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.texParameteri\".");
7639 return false;
7640 }
7641 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
7642 Ok(ConversionResult::Success(value)) => value,
7643 Ok(ConversionResult::Failure(error)) => {
7644 throw_type_error(cx.raw_cx(), &error);
7645 return false;
7646
7647 }
7648 _ => {
7649 return false;
7650
7651 },
7652 }
7653 ;
7654 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
7655 Ok(ConversionResult::Success(value)) => value,
7656 Ok(ConversionResult::Failure(error)) => {
7657 throw_type_error(cx.raw_cx(), &error);
7658 return false;
7659
7660 }
7661 _ => {
7662 return false;
7663
7664 },
7665 }
7666 ;
7667 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
7668 Ok(ConversionResult::Success(value)) => value,
7669 Ok(ConversionResult::Failure(error)) => {
7670 throw_type_error(cx.raw_cx(), &error);
7671 return false;
7672
7673 }
7674 _ => {
7675 return false;
7676
7677 },
7678 }
7679 ;
7680 let result: () = this.TexParameteri(arg0, arg1, arg2);
7681
7682 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7683 return true;
7684 })());
7685 result
7686}
7687
7688
7689static texParameteri_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7690
7691pub(crate) fn init_texParameteri_methodinfo<D: DomTypes>() {
7692 texParameteri_methodinfo.set(JSJitInfo {
7693 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7694 method: Some(texParameteri::<D>)
7695 },
7696 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7697 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7698 },
7699 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7700 _bitfield_align_1: [],
7701 _bitfield_1: __BindgenBitfieldUnit::new(
7702 new_jsjitinfo_bitfield_1!(
7703 JSJitInfo_OpType::Method as u8,
7704 JSJitInfo_AliasSet::AliasEverything as u8,
7705 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7706 false,
7707 false,
7708 false,
7709 false,
7710 false,
7711 false,
7712 0,
7713 ).to_ne_bytes()
7714 ),
7715});
7716}
7717unsafe extern "C" fn uniform1f<D: DomTypes>
7718(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7719 let mut result = false;
7720 wrap_panic(&mut || result = (|| {
7721 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7722 let this = &*(this as *const D::WebGLRenderingContext);
7723 let args = &*args;
7724 let argc = args.argc_;
7725
7726 if argc < 2 {
7727 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform1f\".");
7728 return false;
7729 }
7730 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7731 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7732 Ok(val) => val,
7733 Err(()) => {
7734 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
7735 return false;
7736
7737 }
7738 }
7739 )
7740 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
7741 None
7742 } else {
7743 throw_type_error(cx.raw_cx(), "Value is not an object.");
7744 return false;
7745
7746 };
7747 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
7748 Ok(ConversionResult::Success(value)) => value,
7749 Ok(ConversionResult::Failure(error)) => {
7750 throw_type_error(cx.raw_cx(), &error);
7751 return false;
7752
7753 }
7754 _ => {
7755 return false;
7756
7757 },
7758 }
7759 ;
7760 let result: () = this.Uniform1f(arg0.as_deref(), arg1);
7761
7762 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7763 return true;
7764 })());
7765 result
7766}
7767
7768
7769static uniform1f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7770
7771pub(crate) fn init_uniform1f_methodinfo<D: DomTypes>() {
7772 uniform1f_methodinfo.set(JSJitInfo {
7773 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7774 method: Some(uniform1f::<D>)
7775 },
7776 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7777 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7778 },
7779 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7780 _bitfield_align_1: [],
7781 _bitfield_1: __BindgenBitfieldUnit::new(
7782 new_jsjitinfo_bitfield_1!(
7783 JSJitInfo_OpType::Method as u8,
7784 JSJitInfo_AliasSet::AliasEverything as u8,
7785 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7786 false,
7787 false,
7788 false,
7789 false,
7790 false,
7791 false,
7792 0,
7793 ).to_ne_bytes()
7794 ),
7795});
7796}
7797unsafe extern "C" fn uniform2f<D: DomTypes>
7798(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7799 let mut result = false;
7800 wrap_panic(&mut || result = (|| {
7801 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7802 let this = &*(this as *const D::WebGLRenderingContext);
7803 let args = &*args;
7804 let argc = args.argc_;
7805
7806 if argc < 3 {
7807 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform2f\".");
7808 return false;
7809 }
7810 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7811 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7812 Ok(val) => val,
7813 Err(()) => {
7814 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
7815 return false;
7816
7817 }
7818 }
7819 )
7820 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
7821 None
7822 } else {
7823 throw_type_error(cx.raw_cx(), "Value is not an object.");
7824 return false;
7825
7826 };
7827 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
7828 Ok(ConversionResult::Success(value)) => value,
7829 Ok(ConversionResult::Failure(error)) => {
7830 throw_type_error(cx.raw_cx(), &error);
7831 return false;
7832
7833 }
7834 _ => {
7835 return false;
7836
7837 },
7838 }
7839 ;
7840 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
7841 Ok(ConversionResult::Success(value)) => value,
7842 Ok(ConversionResult::Failure(error)) => {
7843 throw_type_error(cx.raw_cx(), &error);
7844 return false;
7845
7846 }
7847 _ => {
7848 return false;
7849
7850 },
7851 }
7852 ;
7853 let result: () = this.Uniform2f(arg0.as_deref(), arg1, arg2);
7854
7855 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7856 return true;
7857 })());
7858 result
7859}
7860
7861
7862static uniform2f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7863
7864pub(crate) fn init_uniform2f_methodinfo<D: DomTypes>() {
7865 uniform2f_methodinfo.set(JSJitInfo {
7866 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7867 method: Some(uniform2f::<D>)
7868 },
7869 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7870 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7871 },
7872 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7873 _bitfield_align_1: [],
7874 _bitfield_1: __BindgenBitfieldUnit::new(
7875 new_jsjitinfo_bitfield_1!(
7876 JSJitInfo_OpType::Method as u8,
7877 JSJitInfo_AliasSet::AliasEverything as u8,
7878 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7879 false,
7880 false,
7881 false,
7882 false,
7883 false,
7884 false,
7885 0,
7886 ).to_ne_bytes()
7887 ),
7888});
7889}
7890unsafe extern "C" fn uniform3f<D: DomTypes>
7891(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7892 let mut result = false;
7893 wrap_panic(&mut || result = (|| {
7894 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7895 let this = &*(this as *const D::WebGLRenderingContext);
7896 let args = &*args;
7897 let argc = args.argc_;
7898
7899 if argc < 4 {
7900 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform3f\".");
7901 return false;
7902 }
7903 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7904 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7905 Ok(val) => val,
7906 Err(()) => {
7907 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
7908 return false;
7909
7910 }
7911 }
7912 )
7913 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
7914 None
7915 } else {
7916 throw_type_error(cx.raw_cx(), "Value is not an object.");
7917 return false;
7918
7919 };
7920 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
7921 Ok(ConversionResult::Success(value)) => value,
7922 Ok(ConversionResult::Failure(error)) => {
7923 throw_type_error(cx.raw_cx(), &error);
7924 return false;
7925
7926 }
7927 _ => {
7928 return false;
7929
7930 },
7931 }
7932 ;
7933 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
7934 Ok(ConversionResult::Success(value)) => value,
7935 Ok(ConversionResult::Failure(error)) => {
7936 throw_type_error(cx.raw_cx(), &error);
7937 return false;
7938
7939 }
7940 _ => {
7941 return false;
7942
7943 },
7944 }
7945 ;
7946 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
7947 Ok(ConversionResult::Success(value)) => value,
7948 Ok(ConversionResult::Failure(error)) => {
7949 throw_type_error(cx.raw_cx(), &error);
7950 return false;
7951
7952 }
7953 _ => {
7954 return false;
7955
7956 },
7957 }
7958 ;
7959 let result: () = this.Uniform3f(arg0.as_deref(), arg1, arg2, arg3);
7960
7961 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7962 return true;
7963 })());
7964 result
7965}
7966
7967
7968static uniform3f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7969
7970pub(crate) fn init_uniform3f_methodinfo<D: DomTypes>() {
7971 uniform3f_methodinfo.set(JSJitInfo {
7972 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7973 method: Some(uniform3f::<D>)
7974 },
7975 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7976 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
7977 },
7978 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7979 _bitfield_align_1: [],
7980 _bitfield_1: __BindgenBitfieldUnit::new(
7981 new_jsjitinfo_bitfield_1!(
7982 JSJitInfo_OpType::Method as u8,
7983 JSJitInfo_AliasSet::AliasEverything as u8,
7984 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7985 false,
7986 false,
7987 false,
7988 false,
7989 false,
7990 false,
7991 0,
7992 ).to_ne_bytes()
7993 ),
7994});
7995}
7996unsafe extern "C" fn uniform4f<D: DomTypes>
7997(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
7998 let mut result = false;
7999 wrap_panic(&mut || result = (|| {
8000 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8001 let this = &*(this as *const D::WebGLRenderingContext);
8002 let args = &*args;
8003 let argc = args.argc_;
8004
8005 if argc < 5 {
8006 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform4f\".");
8007 return false;
8008 }
8009 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8010 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
8011 Ok(val) => val,
8012 Err(()) => {
8013 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
8014 return false;
8015
8016 }
8017 }
8018 )
8019 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
8020 None
8021 } else {
8022 throw_type_error(cx.raw_cx(), "Value is not an object.");
8023 return false;
8024
8025 };
8026 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
8027 Ok(ConversionResult::Success(value)) => value,
8028 Ok(ConversionResult::Failure(error)) => {
8029 throw_type_error(cx.raw_cx(), &error);
8030 return false;
8031
8032 }
8033 _ => {
8034 return false;
8035
8036 },
8037 }
8038 ;
8039 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
8040 Ok(ConversionResult::Success(value)) => value,
8041 Ok(ConversionResult::Failure(error)) => {
8042 throw_type_error(cx.raw_cx(), &error);
8043 return false;
8044
8045 }
8046 _ => {
8047 return false;
8048
8049 },
8050 }
8051 ;
8052 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
8053 Ok(ConversionResult::Success(value)) => value,
8054 Ok(ConversionResult::Failure(error)) => {
8055 throw_type_error(cx.raw_cx(), &error);
8056 return false;
8057
8058 }
8059 _ => {
8060 return false;
8061
8062 },
8063 }
8064 ;
8065 let arg4: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ()) {
8066 Ok(ConversionResult::Success(value)) => value,
8067 Ok(ConversionResult::Failure(error)) => {
8068 throw_type_error(cx.raw_cx(), &error);
8069 return false;
8070
8071 }
8072 _ => {
8073 return false;
8074
8075 },
8076 }
8077 ;
8078 let result: () = this.Uniform4f(arg0.as_deref(), arg1, arg2, arg3, arg4);
8079
8080 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8081 return true;
8082 })());
8083 result
8084}
8085
8086
8087static uniform4f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8088
8089pub(crate) fn init_uniform4f_methodinfo<D: DomTypes>() {
8090 uniform4f_methodinfo.set(JSJitInfo {
8091 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8092 method: Some(uniform4f::<D>)
8093 },
8094 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8095 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8096 },
8097 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8098 _bitfield_align_1: [],
8099 _bitfield_1: __BindgenBitfieldUnit::new(
8100 new_jsjitinfo_bitfield_1!(
8101 JSJitInfo_OpType::Method as u8,
8102 JSJitInfo_AliasSet::AliasEverything as u8,
8103 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8104 false,
8105 false,
8106 false,
8107 false,
8108 false,
8109 false,
8110 0,
8111 ).to_ne_bytes()
8112 ),
8113});
8114}
8115unsafe extern "C" fn uniform1i<D: DomTypes>
8116(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8117 let mut result = false;
8118 wrap_panic(&mut || result = (|| {
8119 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8120 let this = &*(this as *const D::WebGLRenderingContext);
8121 let args = &*args;
8122 let argc = args.argc_;
8123
8124 if argc < 2 {
8125 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform1i\".");
8126 return false;
8127 }
8128 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8129 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
8130 Ok(val) => val,
8131 Err(()) => {
8132 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
8133 return false;
8134
8135 }
8136 }
8137 )
8138 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
8139 None
8140 } else {
8141 throw_type_error(cx.raw_cx(), "Value is not an object.");
8142 return false;
8143
8144 };
8145 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8146 Ok(ConversionResult::Success(value)) => value,
8147 Ok(ConversionResult::Failure(error)) => {
8148 throw_type_error(cx.raw_cx(), &error);
8149 return false;
8150
8151 }
8152 _ => {
8153 return false;
8154
8155 },
8156 }
8157 ;
8158 let result: () = this.Uniform1i(arg0.as_deref(), arg1);
8159
8160 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8161 return true;
8162 })());
8163 result
8164}
8165
8166
8167static uniform1i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8168
8169pub(crate) fn init_uniform1i_methodinfo<D: DomTypes>() {
8170 uniform1i_methodinfo.set(JSJitInfo {
8171 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8172 method: Some(uniform1i::<D>)
8173 },
8174 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8175 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8176 },
8177 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8178 _bitfield_align_1: [],
8179 _bitfield_1: __BindgenBitfieldUnit::new(
8180 new_jsjitinfo_bitfield_1!(
8181 JSJitInfo_OpType::Method as u8,
8182 JSJitInfo_AliasSet::AliasEverything as u8,
8183 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8184 false,
8185 false,
8186 false,
8187 false,
8188 false,
8189 false,
8190 0,
8191 ).to_ne_bytes()
8192 ),
8193});
8194}
8195unsafe extern "C" fn uniform2i<D: DomTypes>
8196(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8197 let mut result = false;
8198 wrap_panic(&mut || result = (|| {
8199 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8200 let this = &*(this as *const D::WebGLRenderingContext);
8201 let args = &*args;
8202 let argc = args.argc_;
8203
8204 if argc < 3 {
8205 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform2i\".");
8206 return false;
8207 }
8208 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8209 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
8210 Ok(val) => val,
8211 Err(()) => {
8212 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
8213 return false;
8214
8215 }
8216 }
8217 )
8218 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
8219 None
8220 } else {
8221 throw_type_error(cx.raw_cx(), "Value is not an object.");
8222 return false;
8223
8224 };
8225 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8226 Ok(ConversionResult::Success(value)) => value,
8227 Ok(ConversionResult::Failure(error)) => {
8228 throw_type_error(cx.raw_cx(), &error);
8229 return false;
8230
8231 }
8232 _ => {
8233 return false;
8234
8235 },
8236 }
8237 ;
8238 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
8239 Ok(ConversionResult::Success(value)) => value,
8240 Ok(ConversionResult::Failure(error)) => {
8241 throw_type_error(cx.raw_cx(), &error);
8242 return false;
8243
8244 }
8245 _ => {
8246 return false;
8247
8248 },
8249 }
8250 ;
8251 let result: () = this.Uniform2i(arg0.as_deref(), arg1, arg2);
8252
8253 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8254 return true;
8255 })());
8256 result
8257}
8258
8259
8260static uniform2i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8261
8262pub(crate) fn init_uniform2i_methodinfo<D: DomTypes>() {
8263 uniform2i_methodinfo.set(JSJitInfo {
8264 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8265 method: Some(uniform2i::<D>)
8266 },
8267 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8268 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8269 },
8270 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8271 _bitfield_align_1: [],
8272 _bitfield_1: __BindgenBitfieldUnit::new(
8273 new_jsjitinfo_bitfield_1!(
8274 JSJitInfo_OpType::Method as u8,
8275 JSJitInfo_AliasSet::AliasEverything as u8,
8276 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8277 false,
8278 false,
8279 false,
8280 false,
8281 false,
8282 false,
8283 0,
8284 ).to_ne_bytes()
8285 ),
8286});
8287}
8288unsafe extern "C" fn uniform3i<D: DomTypes>
8289(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8290 let mut result = false;
8291 wrap_panic(&mut || result = (|| {
8292 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8293 let this = &*(this as *const D::WebGLRenderingContext);
8294 let args = &*args;
8295 let argc = args.argc_;
8296
8297 if argc < 4 {
8298 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform3i\".");
8299 return false;
8300 }
8301 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8302 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
8303 Ok(val) => val,
8304 Err(()) => {
8305 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
8306 return false;
8307
8308 }
8309 }
8310 )
8311 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
8312 None
8313 } else {
8314 throw_type_error(cx.raw_cx(), "Value is not an object.");
8315 return false;
8316
8317 };
8318 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8319 Ok(ConversionResult::Success(value)) => value,
8320 Ok(ConversionResult::Failure(error)) => {
8321 throw_type_error(cx.raw_cx(), &error);
8322 return false;
8323
8324 }
8325 _ => {
8326 return false;
8327
8328 },
8329 }
8330 ;
8331 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
8332 Ok(ConversionResult::Success(value)) => value,
8333 Ok(ConversionResult::Failure(error)) => {
8334 throw_type_error(cx.raw_cx(), &error);
8335 return false;
8336
8337 }
8338 _ => {
8339 return false;
8340
8341 },
8342 }
8343 ;
8344 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8345 Ok(ConversionResult::Success(value)) => value,
8346 Ok(ConversionResult::Failure(error)) => {
8347 throw_type_error(cx.raw_cx(), &error);
8348 return false;
8349
8350 }
8351 _ => {
8352 return false;
8353
8354 },
8355 }
8356 ;
8357 let result: () = this.Uniform3i(arg0.as_deref(), arg1, arg2, arg3);
8358
8359 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8360 return true;
8361 })());
8362 result
8363}
8364
8365
8366static uniform3i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8367
8368pub(crate) fn init_uniform3i_methodinfo<D: DomTypes>() {
8369 uniform3i_methodinfo.set(JSJitInfo {
8370 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8371 method: Some(uniform3i::<D>)
8372 },
8373 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8374 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8375 },
8376 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8377 _bitfield_align_1: [],
8378 _bitfield_1: __BindgenBitfieldUnit::new(
8379 new_jsjitinfo_bitfield_1!(
8380 JSJitInfo_OpType::Method as u8,
8381 JSJitInfo_AliasSet::AliasEverything as u8,
8382 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8383 false,
8384 false,
8385 false,
8386 false,
8387 false,
8388 false,
8389 0,
8390 ).to_ne_bytes()
8391 ),
8392});
8393}
8394unsafe extern "C" fn uniform4i<D: DomTypes>
8395(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8396 let mut result = false;
8397 wrap_panic(&mut || result = (|| {
8398 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8399 let this = &*(this as *const D::WebGLRenderingContext);
8400 let args = &*args;
8401 let argc = args.argc_;
8402
8403 if argc < 5 {
8404 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform4i\".");
8405 return false;
8406 }
8407 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8408 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
8409 Ok(val) => val,
8410 Err(()) => {
8411 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
8412 return false;
8413
8414 }
8415 }
8416 )
8417 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
8418 None
8419 } else {
8420 throw_type_error(cx.raw_cx(), "Value is not an object.");
8421 return false;
8422
8423 };
8424 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
8425 Ok(ConversionResult::Success(value)) => value,
8426 Ok(ConversionResult::Failure(error)) => {
8427 throw_type_error(cx.raw_cx(), &error);
8428 return false;
8429
8430 }
8431 _ => {
8432 return false;
8433
8434 },
8435 }
8436 ;
8437 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
8438 Ok(ConversionResult::Success(value)) => value,
8439 Ok(ConversionResult::Failure(error)) => {
8440 throw_type_error(cx.raw_cx(), &error);
8441 return false;
8442
8443 }
8444 _ => {
8445 return false;
8446
8447 },
8448 }
8449 ;
8450 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
8451 Ok(ConversionResult::Success(value)) => value,
8452 Ok(ConversionResult::Failure(error)) => {
8453 throw_type_error(cx.raw_cx(), &error);
8454 return false;
8455
8456 }
8457 _ => {
8458 return false;
8459
8460 },
8461 }
8462 ;
8463 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
8464 Ok(ConversionResult::Success(value)) => value,
8465 Ok(ConversionResult::Failure(error)) => {
8466 throw_type_error(cx.raw_cx(), &error);
8467 return false;
8468
8469 }
8470 _ => {
8471 return false;
8472
8473 },
8474 }
8475 ;
8476 let result: () = this.Uniform4i(arg0.as_deref(), arg1, arg2, arg3, arg4);
8477
8478 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8479 return true;
8480 })());
8481 result
8482}
8483
8484
8485static uniform4i_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8486
8487pub(crate) fn init_uniform4i_methodinfo<D: DomTypes>() {
8488 uniform4i_methodinfo.set(JSJitInfo {
8489 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8490 method: Some(uniform4i::<D>)
8491 },
8492 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8493 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8494 },
8495 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8496 _bitfield_align_1: [],
8497 _bitfield_1: __BindgenBitfieldUnit::new(
8498 new_jsjitinfo_bitfield_1!(
8499 JSJitInfo_OpType::Method as u8,
8500 JSJitInfo_AliasSet::AliasEverything as u8,
8501 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8502 false,
8503 false,
8504 false,
8505 false,
8506 false,
8507 false,
8508 0,
8509 ).to_ne_bytes()
8510 ),
8511});
8512}
8513unsafe extern "C" fn useProgram<D: DomTypes>
8514(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8515 let mut result = false;
8516 wrap_panic(&mut || result = (|| {
8517 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8518 let this = &*(this as *const D::WebGLRenderingContext);
8519 let args = &*args;
8520 let argc = args.argc_;
8521
8522 if argc < 1 {
8523 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.useProgram\".");
8524 return false;
8525 }
8526 let arg0: Option<DomRoot<D::WebGLProgram>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8527 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
8528 Ok(val) => val,
8529 Err(()) => {
8530 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
8531 return false;
8532
8533 }
8534 }
8535 )
8536 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
8537 None
8538 } else {
8539 throw_type_error(cx.raw_cx(), "Value is not an object.");
8540 return false;
8541
8542 };
8543 let result: () = this.UseProgram(arg0.as_deref());
8544
8545 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8546 return true;
8547 })());
8548 result
8549}
8550
8551
8552static useProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8553
8554pub(crate) fn init_useProgram_methodinfo<D: DomTypes>() {
8555 useProgram_methodinfo.set(JSJitInfo {
8556 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8557 method: Some(useProgram::<D>)
8558 },
8559 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8560 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8561 },
8562 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8563 _bitfield_align_1: [],
8564 _bitfield_1: __BindgenBitfieldUnit::new(
8565 new_jsjitinfo_bitfield_1!(
8566 JSJitInfo_OpType::Method as u8,
8567 JSJitInfo_AliasSet::AliasEverything as u8,
8568 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8569 false,
8570 false,
8571 false,
8572 false,
8573 false,
8574 false,
8575 0,
8576 ).to_ne_bytes()
8577 ),
8578});
8579}
8580unsafe extern "C" fn validateProgram<D: DomTypes>
8581(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8582 let mut result = false;
8583 wrap_panic(&mut || result = (|| {
8584 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8585 let this = &*(this as *const D::WebGLRenderingContext);
8586 let args = &*args;
8587 let argc = args.argc_;
8588
8589 if argc < 1 {
8590 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.validateProgram\".");
8591 return false;
8592 }
8593 let arg0: DomRoot<D::WebGLProgram> = if HandleValue::from_raw(args.get(0)).get().is_object() {
8594 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
8595 Ok(val) => val,
8596 Err(()) => {
8597 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLProgram.");
8598 return false;
8599
8600 }
8601 }
8602
8603 } else {
8604 throw_type_error(cx.raw_cx(), "Value is not an object.");
8605 return false;
8606
8607 };
8608 let result: () = this.ValidateProgram(&arg0);
8609
8610 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8611 return true;
8612 })());
8613 result
8614}
8615
8616
8617static validateProgram_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8618
8619pub(crate) fn init_validateProgram_methodinfo<D: DomTypes>() {
8620 validateProgram_methodinfo.set(JSJitInfo {
8621 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8622 method: Some(validateProgram::<D>)
8623 },
8624 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8625 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8626 },
8627 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8628 _bitfield_align_1: [],
8629 _bitfield_1: __BindgenBitfieldUnit::new(
8630 new_jsjitinfo_bitfield_1!(
8631 JSJitInfo_OpType::Method as u8,
8632 JSJitInfo_AliasSet::AliasEverything as u8,
8633 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8634 false,
8635 false,
8636 false,
8637 false,
8638 false,
8639 false,
8640 0,
8641 ).to_ne_bytes()
8642 ),
8643});
8644}
8645unsafe extern "C" fn vertexAttrib1f<D: DomTypes>
8646(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8647 let mut result = false;
8648 wrap_panic(&mut || result = (|| {
8649 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8650 let this = &*(this as *const D::WebGLRenderingContext);
8651 let args = &*args;
8652 let argc = args.argc_;
8653
8654 if argc < 2 {
8655 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttrib1f\".");
8656 return false;
8657 }
8658 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8659 Ok(ConversionResult::Success(value)) => value,
8660 Ok(ConversionResult::Failure(error)) => {
8661 throw_type_error(cx.raw_cx(), &error);
8662 return false;
8663
8664 }
8665 _ => {
8666 return false;
8667
8668 },
8669 }
8670 ;
8671 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
8672 Ok(ConversionResult::Success(value)) => value,
8673 Ok(ConversionResult::Failure(error)) => {
8674 throw_type_error(cx.raw_cx(), &error);
8675 return false;
8676
8677 }
8678 _ => {
8679 return false;
8680
8681 },
8682 }
8683 ;
8684 let result: () = this.VertexAttrib1f(arg0, arg1);
8685
8686 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8687 return true;
8688 })());
8689 result
8690}
8691
8692
8693static vertexAttrib1f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8694
8695pub(crate) fn init_vertexAttrib1f_methodinfo<D: DomTypes>() {
8696 vertexAttrib1f_methodinfo.set(JSJitInfo {
8697 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8698 method: Some(vertexAttrib1f::<D>)
8699 },
8700 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8701 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8702 },
8703 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8704 _bitfield_align_1: [],
8705 _bitfield_1: __BindgenBitfieldUnit::new(
8706 new_jsjitinfo_bitfield_1!(
8707 JSJitInfo_OpType::Method as u8,
8708 JSJitInfo_AliasSet::AliasEverything as u8,
8709 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8710 false,
8711 false,
8712 false,
8713 false,
8714 false,
8715 false,
8716 0,
8717 ).to_ne_bytes()
8718 ),
8719});
8720}
8721unsafe extern "C" fn vertexAttrib2f<D: DomTypes>
8722(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8723 let mut result = false;
8724 wrap_panic(&mut || result = (|| {
8725 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8726 let this = &*(this as *const D::WebGLRenderingContext);
8727 let args = &*args;
8728 let argc = args.argc_;
8729
8730 if argc < 3 {
8731 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttrib2f\".");
8732 return false;
8733 }
8734 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8735 Ok(ConversionResult::Success(value)) => value,
8736 Ok(ConversionResult::Failure(error)) => {
8737 throw_type_error(cx.raw_cx(), &error);
8738 return false;
8739
8740 }
8741 _ => {
8742 return false;
8743
8744 },
8745 }
8746 ;
8747 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
8748 Ok(ConversionResult::Success(value)) => value,
8749 Ok(ConversionResult::Failure(error)) => {
8750 throw_type_error(cx.raw_cx(), &error);
8751 return false;
8752
8753 }
8754 _ => {
8755 return false;
8756
8757 },
8758 }
8759 ;
8760 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
8761 Ok(ConversionResult::Success(value)) => value,
8762 Ok(ConversionResult::Failure(error)) => {
8763 throw_type_error(cx.raw_cx(), &error);
8764 return false;
8765
8766 }
8767 _ => {
8768 return false;
8769
8770 },
8771 }
8772 ;
8773 let result: () = this.VertexAttrib2f(arg0, arg1, arg2);
8774
8775 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8776 return true;
8777 })());
8778 result
8779}
8780
8781
8782static vertexAttrib2f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8783
8784pub(crate) fn init_vertexAttrib2f_methodinfo<D: DomTypes>() {
8785 vertexAttrib2f_methodinfo.set(JSJitInfo {
8786 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8787 method: Some(vertexAttrib2f::<D>)
8788 },
8789 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8790 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8791 },
8792 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8793 _bitfield_align_1: [],
8794 _bitfield_1: __BindgenBitfieldUnit::new(
8795 new_jsjitinfo_bitfield_1!(
8796 JSJitInfo_OpType::Method as u8,
8797 JSJitInfo_AliasSet::AliasEverything as u8,
8798 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8799 false,
8800 false,
8801 false,
8802 false,
8803 false,
8804 false,
8805 0,
8806 ).to_ne_bytes()
8807 ),
8808});
8809}
8810unsafe extern "C" fn vertexAttrib3f<D: DomTypes>
8811(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8812 let mut result = false;
8813 wrap_panic(&mut || result = (|| {
8814 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8815 let this = &*(this as *const D::WebGLRenderingContext);
8816 let args = &*args;
8817 let argc = args.argc_;
8818
8819 if argc < 4 {
8820 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttrib3f\".");
8821 return false;
8822 }
8823 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8824 Ok(ConversionResult::Success(value)) => value,
8825 Ok(ConversionResult::Failure(error)) => {
8826 throw_type_error(cx.raw_cx(), &error);
8827 return false;
8828
8829 }
8830 _ => {
8831 return false;
8832
8833 },
8834 }
8835 ;
8836 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
8837 Ok(ConversionResult::Success(value)) => value,
8838 Ok(ConversionResult::Failure(error)) => {
8839 throw_type_error(cx.raw_cx(), &error);
8840 return false;
8841
8842 }
8843 _ => {
8844 return false;
8845
8846 },
8847 }
8848 ;
8849 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
8850 Ok(ConversionResult::Success(value)) => value,
8851 Ok(ConversionResult::Failure(error)) => {
8852 throw_type_error(cx.raw_cx(), &error);
8853 return false;
8854
8855 }
8856 _ => {
8857 return false;
8858
8859 },
8860 }
8861 ;
8862 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
8863 Ok(ConversionResult::Success(value)) => value,
8864 Ok(ConversionResult::Failure(error)) => {
8865 throw_type_error(cx.raw_cx(), &error);
8866 return false;
8867
8868 }
8869 _ => {
8870 return false;
8871
8872 },
8873 }
8874 ;
8875 let result: () = this.VertexAttrib3f(arg0, arg1, arg2, arg3);
8876
8877 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8878 return true;
8879 })());
8880 result
8881}
8882
8883
8884static vertexAttrib3f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8885
8886pub(crate) fn init_vertexAttrib3f_methodinfo<D: DomTypes>() {
8887 vertexAttrib3f_methodinfo.set(JSJitInfo {
8888 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8889 method: Some(vertexAttrib3f::<D>)
8890 },
8891 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8892 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
8893 },
8894 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8895 _bitfield_align_1: [],
8896 _bitfield_1: __BindgenBitfieldUnit::new(
8897 new_jsjitinfo_bitfield_1!(
8898 JSJitInfo_OpType::Method as u8,
8899 JSJitInfo_AliasSet::AliasEverything as u8,
8900 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8901 false,
8902 false,
8903 false,
8904 false,
8905 false,
8906 false,
8907 0,
8908 ).to_ne_bytes()
8909 ),
8910});
8911}
8912unsafe extern "C" fn vertexAttrib4f<D: DomTypes>
8913(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8914 let mut result = false;
8915 wrap_panic(&mut || result = (|| {
8916 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8917 let this = &*(this as *const D::WebGLRenderingContext);
8918 let args = &*args;
8919 let argc = args.argc_;
8920
8921 if argc < 5 {
8922 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttrib4f\".");
8923 return false;
8924 }
8925 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
8926 Ok(ConversionResult::Success(value)) => value,
8927 Ok(ConversionResult::Failure(error)) => {
8928 throw_type_error(cx.raw_cx(), &error);
8929 return false;
8930
8931 }
8932 _ => {
8933 return false;
8934
8935 },
8936 }
8937 ;
8938 let arg1: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
8939 Ok(ConversionResult::Success(value)) => value,
8940 Ok(ConversionResult::Failure(error)) => {
8941 throw_type_error(cx.raw_cx(), &error);
8942 return false;
8943
8944 }
8945 _ => {
8946 return false;
8947
8948 },
8949 }
8950 ;
8951 let arg2: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
8952 Ok(ConversionResult::Success(value)) => value,
8953 Ok(ConversionResult::Failure(error)) => {
8954 throw_type_error(cx.raw_cx(), &error);
8955 return false;
8956
8957 }
8958 _ => {
8959 return false;
8960
8961 },
8962 }
8963 ;
8964 let arg3: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
8965 Ok(ConversionResult::Success(value)) => value,
8966 Ok(ConversionResult::Failure(error)) => {
8967 throw_type_error(cx.raw_cx(), &error);
8968 return false;
8969
8970 }
8971 _ => {
8972 return false;
8973
8974 },
8975 }
8976 ;
8977 let arg4: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ()) {
8978 Ok(ConversionResult::Success(value)) => value,
8979 Ok(ConversionResult::Failure(error)) => {
8980 throw_type_error(cx.raw_cx(), &error);
8981 return false;
8982
8983 }
8984 _ => {
8985 return false;
8986
8987 },
8988 }
8989 ;
8990 let result: () = this.VertexAttrib4f(arg0, arg1, arg2, arg3, arg4);
8991
8992 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8993 return true;
8994 })());
8995 result
8996}
8997
8998
8999static vertexAttrib4f_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9000
9001pub(crate) fn init_vertexAttrib4f_methodinfo<D: DomTypes>() {
9002 vertexAttrib4f_methodinfo.set(JSJitInfo {
9003 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9004 method: Some(vertexAttrib4f::<D>)
9005 },
9006 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9007 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9008 },
9009 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9010 _bitfield_align_1: [],
9011 _bitfield_1: __BindgenBitfieldUnit::new(
9012 new_jsjitinfo_bitfield_1!(
9013 JSJitInfo_OpType::Method as u8,
9014 JSJitInfo_AliasSet::AliasEverything as u8,
9015 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9016 false,
9017 false,
9018 false,
9019 false,
9020 false,
9021 false,
9022 0,
9023 ).to_ne_bytes()
9024 ),
9025});
9026}
9027unsafe extern "C" fn vertexAttrib1fv<D: DomTypes>
9028(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9029 let mut result = false;
9030 wrap_panic(&mut || result = (|| {
9031 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9032 let this = &*(this as *const D::WebGLRenderingContext);
9033 let args = &*args;
9034 let argc = args.argc_;
9035
9036 if argc < 2 {
9037 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttrib1fv\".");
9038 return false;
9039 }
9040 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9041 Ok(ConversionResult::Success(value)) => value,
9042 Ok(ConversionResult::Failure(error)) => {
9043 throw_type_error(cx.raw_cx(), &error);
9044 return false;
9045
9046 }
9047 _ => {
9048 return false;
9049
9050 },
9051 }
9052 ;
9053 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9054 Ok(ConversionResult::Success(value)) => value,
9055 Ok(ConversionResult::Failure(error)) => {
9056 throw_type_error(cx.raw_cx(), &error);
9057 return false;
9058
9059 }
9060 _ => {
9061 return false;
9062
9063 },
9064 }
9065 ;
9066 let result: () = this.VertexAttrib1fv(arg0, arg1);
9067
9068 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9069 return true;
9070 })());
9071 result
9072}
9073
9074
9075static vertexAttrib1fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9076
9077pub(crate) fn init_vertexAttrib1fv_methodinfo<D: DomTypes>() {
9078 vertexAttrib1fv_methodinfo.set(JSJitInfo {
9079 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9080 method: Some(vertexAttrib1fv::<D>)
9081 },
9082 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9083 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9084 },
9085 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9086 _bitfield_align_1: [],
9087 _bitfield_1: __BindgenBitfieldUnit::new(
9088 new_jsjitinfo_bitfield_1!(
9089 JSJitInfo_OpType::Method as u8,
9090 JSJitInfo_AliasSet::AliasEverything as u8,
9091 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9092 false,
9093 false,
9094 false,
9095 false,
9096 false,
9097 false,
9098 0,
9099 ).to_ne_bytes()
9100 ),
9101});
9102}
9103unsafe extern "C" fn vertexAttrib2fv<D: DomTypes>
9104(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9105 let mut result = false;
9106 wrap_panic(&mut || result = (|| {
9107 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9108 let this = &*(this as *const D::WebGLRenderingContext);
9109 let args = &*args;
9110 let argc = args.argc_;
9111
9112 if argc < 2 {
9113 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttrib2fv\".");
9114 return false;
9115 }
9116 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9117 Ok(ConversionResult::Success(value)) => value,
9118 Ok(ConversionResult::Failure(error)) => {
9119 throw_type_error(cx.raw_cx(), &error);
9120 return false;
9121
9122 }
9123 _ => {
9124 return false;
9125
9126 },
9127 }
9128 ;
9129 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9130 Ok(ConversionResult::Success(value)) => value,
9131 Ok(ConversionResult::Failure(error)) => {
9132 throw_type_error(cx.raw_cx(), &error);
9133 return false;
9134
9135 }
9136 _ => {
9137 return false;
9138
9139 },
9140 }
9141 ;
9142 let result: () = this.VertexAttrib2fv(arg0, arg1);
9143
9144 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9145 return true;
9146 })());
9147 result
9148}
9149
9150
9151static vertexAttrib2fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9152
9153pub(crate) fn init_vertexAttrib2fv_methodinfo<D: DomTypes>() {
9154 vertexAttrib2fv_methodinfo.set(JSJitInfo {
9155 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9156 method: Some(vertexAttrib2fv::<D>)
9157 },
9158 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9159 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9160 },
9161 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9162 _bitfield_align_1: [],
9163 _bitfield_1: __BindgenBitfieldUnit::new(
9164 new_jsjitinfo_bitfield_1!(
9165 JSJitInfo_OpType::Method as u8,
9166 JSJitInfo_AliasSet::AliasEverything as u8,
9167 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9168 false,
9169 false,
9170 false,
9171 false,
9172 false,
9173 false,
9174 0,
9175 ).to_ne_bytes()
9176 ),
9177});
9178}
9179unsafe extern "C" fn vertexAttrib3fv<D: DomTypes>
9180(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9181 let mut result = false;
9182 wrap_panic(&mut || result = (|| {
9183 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9184 let this = &*(this as *const D::WebGLRenderingContext);
9185 let args = &*args;
9186 let argc = args.argc_;
9187
9188 if argc < 2 {
9189 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttrib3fv\".");
9190 return false;
9191 }
9192 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9193 Ok(ConversionResult::Success(value)) => value,
9194 Ok(ConversionResult::Failure(error)) => {
9195 throw_type_error(cx.raw_cx(), &error);
9196 return false;
9197
9198 }
9199 _ => {
9200 return false;
9201
9202 },
9203 }
9204 ;
9205 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9206 Ok(ConversionResult::Success(value)) => value,
9207 Ok(ConversionResult::Failure(error)) => {
9208 throw_type_error(cx.raw_cx(), &error);
9209 return false;
9210
9211 }
9212 _ => {
9213 return false;
9214
9215 },
9216 }
9217 ;
9218 let result: () = this.VertexAttrib3fv(arg0, arg1);
9219
9220 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9221 return true;
9222 })());
9223 result
9224}
9225
9226
9227static vertexAttrib3fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9228
9229pub(crate) fn init_vertexAttrib3fv_methodinfo<D: DomTypes>() {
9230 vertexAttrib3fv_methodinfo.set(JSJitInfo {
9231 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9232 method: Some(vertexAttrib3fv::<D>)
9233 },
9234 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9235 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9236 },
9237 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9238 _bitfield_align_1: [],
9239 _bitfield_1: __BindgenBitfieldUnit::new(
9240 new_jsjitinfo_bitfield_1!(
9241 JSJitInfo_OpType::Method as u8,
9242 JSJitInfo_AliasSet::AliasEverything as u8,
9243 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9244 false,
9245 false,
9246 false,
9247 false,
9248 false,
9249 false,
9250 0,
9251 ).to_ne_bytes()
9252 ),
9253});
9254}
9255unsafe extern "C" fn vertexAttrib4fv<D: DomTypes>
9256(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9257 let mut result = false;
9258 wrap_panic(&mut || result = (|| {
9259 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9260 let this = &*(this as *const D::WebGLRenderingContext);
9261 let args = &*args;
9262 let argc = args.argc_;
9263
9264 if argc < 2 {
9265 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttrib4fv\".");
9266 return false;
9267 }
9268 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9269 Ok(ConversionResult::Success(value)) => value,
9270 Ok(ConversionResult::Failure(error)) => {
9271 throw_type_error(cx.raw_cx(), &error);
9272 return false;
9273
9274 }
9275 _ => {
9276 return false;
9277
9278 },
9279 }
9280 ;
9281 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9282 Ok(ConversionResult::Success(value)) => value,
9283 Ok(ConversionResult::Failure(error)) => {
9284 throw_type_error(cx.raw_cx(), &error);
9285 return false;
9286
9287 }
9288 _ => {
9289 return false;
9290
9291 },
9292 }
9293 ;
9294 let result: () = this.VertexAttrib4fv(arg0, arg1);
9295
9296 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9297 return true;
9298 })());
9299 result
9300}
9301
9302
9303static vertexAttrib4fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9304
9305pub(crate) fn init_vertexAttrib4fv_methodinfo<D: DomTypes>() {
9306 vertexAttrib4fv_methodinfo.set(JSJitInfo {
9307 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9308 method: Some(vertexAttrib4fv::<D>)
9309 },
9310 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9311 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9312 },
9313 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9314 _bitfield_align_1: [],
9315 _bitfield_1: __BindgenBitfieldUnit::new(
9316 new_jsjitinfo_bitfield_1!(
9317 JSJitInfo_OpType::Method as u8,
9318 JSJitInfo_AliasSet::AliasEverything as u8,
9319 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9320 false,
9321 false,
9322 false,
9323 false,
9324 false,
9325 false,
9326 0,
9327 ).to_ne_bytes()
9328 ),
9329});
9330}
9331unsafe extern "C" fn vertexAttribPointer<D: DomTypes>
9332(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9333 let mut result = false;
9334 wrap_panic(&mut || result = (|| {
9335 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9336 let this = &*(this as *const D::WebGLRenderingContext);
9337 let args = &*args;
9338 let argc = args.argc_;
9339
9340 if argc < 6 {
9341 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.vertexAttribPointer\".");
9342 return false;
9343 }
9344 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9345 Ok(ConversionResult::Success(value)) => value,
9346 Ok(ConversionResult::Failure(error)) => {
9347 throw_type_error(cx.raw_cx(), &error);
9348 return false;
9349
9350 }
9351 _ => {
9352 return false;
9353
9354 },
9355 }
9356 ;
9357 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
9358 Ok(ConversionResult::Success(value)) => value,
9359 Ok(ConversionResult::Failure(error)) => {
9360 throw_type_error(cx.raw_cx(), &error);
9361 return false;
9362
9363 }
9364 _ => {
9365 return false;
9366
9367 },
9368 }
9369 ;
9370 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9371 Ok(ConversionResult::Success(value)) => value,
9372 Ok(ConversionResult::Failure(error)) => {
9373 throw_type_error(cx.raw_cx(), &error);
9374 return false;
9375
9376 }
9377 _ => {
9378 return false;
9379
9380 },
9381 }
9382 ;
9383 let arg3: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
9384 Ok(ConversionResult::Success(value)) => value,
9385 Ok(ConversionResult::Failure(error)) => {
9386 throw_type_error(cx.raw_cx(), &error);
9387 return false;
9388
9389 }
9390 _ => {
9391 return false;
9392
9393 },
9394 }
9395 ;
9396 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
9397 Ok(ConversionResult::Success(value)) => value,
9398 Ok(ConversionResult::Failure(error)) => {
9399 throw_type_error(cx.raw_cx(), &error);
9400 return false;
9401
9402 }
9403 _ => {
9404 return false;
9405
9406 },
9407 }
9408 ;
9409 let arg5: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
9410 Ok(ConversionResult::Success(value)) => value,
9411 Ok(ConversionResult::Failure(error)) => {
9412 throw_type_error(cx.raw_cx(), &error);
9413 return false;
9414
9415 }
9416 _ => {
9417 return false;
9418
9419 },
9420 }
9421 ;
9422 let result: () = this.VertexAttribPointer(arg0, arg1, arg2, arg3, arg4, arg5);
9423
9424 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9425 return true;
9426 })());
9427 result
9428}
9429
9430
9431static vertexAttribPointer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9432
9433pub(crate) fn init_vertexAttribPointer_methodinfo<D: DomTypes>() {
9434 vertexAttribPointer_methodinfo.set(JSJitInfo {
9435 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9436 method: Some(vertexAttribPointer::<D>)
9437 },
9438 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9439 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9440 },
9441 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9442 _bitfield_align_1: [],
9443 _bitfield_1: __BindgenBitfieldUnit::new(
9444 new_jsjitinfo_bitfield_1!(
9445 JSJitInfo_OpType::Method as u8,
9446 JSJitInfo_AliasSet::AliasEverything as u8,
9447 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9448 false,
9449 false,
9450 false,
9451 false,
9452 false,
9453 false,
9454 0,
9455 ).to_ne_bytes()
9456 ),
9457});
9458}
9459unsafe extern "C" fn viewport<D: DomTypes>
9460(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9461 let mut result = false;
9462 wrap_panic(&mut || result = (|| {
9463 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9464 let this = &*(this as *const D::WebGLRenderingContext);
9465 let args = &*args;
9466 let argc = args.argc_;
9467
9468 if argc < 4 {
9469 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.viewport\".");
9470 return false;
9471 }
9472 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9473 Ok(ConversionResult::Success(value)) => value,
9474 Ok(ConversionResult::Failure(error)) => {
9475 throw_type_error(cx.raw_cx(), &error);
9476 return false;
9477
9478 }
9479 _ => {
9480 return false;
9481
9482 },
9483 }
9484 ;
9485 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
9486 Ok(ConversionResult::Success(value)) => value,
9487 Ok(ConversionResult::Failure(error)) => {
9488 throw_type_error(cx.raw_cx(), &error);
9489 return false;
9490
9491 }
9492 _ => {
9493 return false;
9494
9495 },
9496 }
9497 ;
9498 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9499 Ok(ConversionResult::Success(value)) => value,
9500 Ok(ConversionResult::Failure(error)) => {
9501 throw_type_error(cx.raw_cx(), &error);
9502 return false;
9503
9504 }
9505 _ => {
9506 return false;
9507
9508 },
9509 }
9510 ;
9511 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9512 Ok(ConversionResult::Success(value)) => value,
9513 Ok(ConversionResult::Failure(error)) => {
9514 throw_type_error(cx.raw_cx(), &error);
9515 return false;
9516
9517 }
9518 _ => {
9519 return false;
9520
9521 },
9522 }
9523 ;
9524 let result: () = this.Viewport(arg0, arg1, arg2, arg3);
9525
9526 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9527 return true;
9528 })());
9529 result
9530}
9531
9532
9533static viewport_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9534
9535pub(crate) fn init_viewport_methodinfo<D: DomTypes>() {
9536 viewport_methodinfo.set(JSJitInfo {
9537 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9538 method: Some(viewport::<D>)
9539 },
9540 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9541 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9542 },
9543 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9544 _bitfield_align_1: [],
9545 _bitfield_1: __BindgenBitfieldUnit::new(
9546 new_jsjitinfo_bitfield_1!(
9547 JSJitInfo_OpType::Method as u8,
9548 JSJitInfo_AliasSet::AliasEverything as u8,
9549 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9550 false,
9551 false,
9552 false,
9553 false,
9554 false,
9555 false,
9556 0,
9557 ).to_ne_bytes()
9558 ),
9559});
9560}
9561unsafe extern "C" fn makeXRCompatible<D: DomTypes>
9562(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9563 let mut result = false;
9564 wrap_panic(&mut || result = (|| {
9565 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9566 let this = &*(this as *const D::WebGLRenderingContext);
9567 let args = &*args;
9568 let argc = args.argc_;
9569 let result: Rc<D::Promise> = this.MakeXRCompatible(CanGc::note());
9570
9571 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9572 return true;
9573 })());
9574 result
9575}
9576
9577unsafe extern "C" fn makeXRCompatible_promise_wrapper<D: DomTypes>
9578(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9579 let mut result = false;
9580 wrap_panic(&mut || result = (|| {
9581 let ok = makeXRCompatible::<D>(cx, _obj, this, args);
9582 if ok {
9583 return true;
9584 }
9585 return exception_to_promise(cx, (*args).rval(), CanGc::note());
9586
9587 })());
9588 result
9589}
9590
9591
9592static makeXRCompatible_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9593
9594pub(crate) fn init_makeXRCompatible_methodinfo<D: DomTypes>() {
9595 makeXRCompatible_methodinfo.set(JSJitInfo {
9596 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9597 method: Some(makeXRCompatible_promise_wrapper::<D>)
9598 },
9599 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9600 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9601 },
9602 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9603 _bitfield_align_1: [],
9604 _bitfield_1: __BindgenBitfieldUnit::new(
9605 new_jsjitinfo_bitfield_1!(
9606 JSJitInfo_OpType::Method as u8,
9607 JSJitInfo_AliasSet::AliasEverything as u8,
9608 JSValueType::JSVAL_TYPE_OBJECT as u8,
9609 true,
9610 false,
9611 false,
9612 false,
9613 false,
9614 false,
9615 0,
9616 ).to_ne_bytes()
9617 ),
9618});
9619}
9620unsafe extern "C" fn bufferData<D: DomTypes>
9621(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9622 let mut result = false;
9623 wrap_panic(&mut || result = (|| {
9624 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9625 let this = &*(this as *const D::WebGLRenderingContext);
9626 let args = &*args;
9627 let argc = args.argc_;
9628
9629 let argcount = cmp::min(argc, 3);
9630 match argcount {
9631 3 => {
9632 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9633 Ok(ConversionResult::Success(value)) => value,
9634 Ok(ConversionResult::Failure(error)) => {
9635 throw_type_error(cx.raw_cx(), &error);
9636 return false;
9637
9638 }
9639 _ => {
9640 return false;
9641
9642 },
9643 }
9644 ;
9645 if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
9646 let arg1: Option<GenericUnionTypes::ArrayBufferViewOrArrayBuffer > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9647 Ok(ConversionResult::Success(value)) => value,
9648 Ok(ConversionResult::Failure(error)) => {
9649 throw_type_error(cx.raw_cx(), &error);
9650 return false;
9651
9652 }
9653 _ => {
9654 return false;
9655
9656 },
9657 }
9658 ;
9659 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9660 Ok(ConversionResult::Success(value)) => value,
9661 Ok(ConversionResult::Failure(error)) => {
9662 throw_type_error(cx.raw_cx(), &error);
9663 return false;
9664
9665 }
9666 _ => {
9667 return false;
9668
9669 },
9670 }
9671 ;
9672 let result: () = this.BufferData_(arg0, arg1, arg2);
9673
9674 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9675 return true;
9676 }
9677 if HandleValue::from_raw(args.get(1)).get().is_object() {
9678 '_block: {
9679 let arg1: Option<GenericUnionTypes::ArrayBufferViewOrArrayBuffer > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
9680 Ok(ConversionResult::Success(value)) => value,
9681 Ok(ConversionResult::Failure(error)) => {
9682 break '_block;
9683 }
9684 _ => {
9685 return false;
9686
9687 },
9688 }
9689 ;
9690 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9691 Ok(ConversionResult::Success(value)) => value,
9692 Ok(ConversionResult::Failure(error)) => {
9693 throw_type_error(cx.raw_cx(), &error);
9694 return false;
9695
9696 }
9697 _ => {
9698 return false;
9699
9700 },
9701 }
9702 ;
9703 let result: () = this.BufferData_(arg0, arg1, arg2);
9704
9705 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9706 return true;
9707 }
9708 }
9709 let arg1: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
9710 Ok(ConversionResult::Success(value)) => value,
9711 Ok(ConversionResult::Failure(error)) => {
9712 throw_type_error(cx.raw_cx(), &error);
9713 return false;
9714
9715 }
9716 _ => {
9717 return false;
9718
9719 },
9720 }
9721 ;
9722 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9723 Ok(ConversionResult::Success(value)) => value,
9724 Ok(ConversionResult::Failure(error)) => {
9725 throw_type_error(cx.raw_cx(), &error);
9726 return false;
9727
9728 }
9729 _ => {
9730 return false;
9731
9732 },
9733 }
9734 ;
9735 let result: () = this.BufferData(arg0, arg1, arg2);
9736
9737 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9738 return true;
9739 }
9740 _ => {
9741 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.bufferData\".");
9742 return false;
9743 }
9744 }
9745 })());
9746 result
9747}
9748
9749
9750static bufferData_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9751
9752pub(crate) fn init_bufferData_methodinfo<D: DomTypes>() {
9753 bufferData_methodinfo.set(JSJitInfo {
9754 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9755 method: Some(bufferData::<D>)
9756 },
9757 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9758 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9759 },
9760 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9761 _bitfield_align_1: [],
9762 _bitfield_1: __BindgenBitfieldUnit::new(
9763 new_jsjitinfo_bitfield_1!(
9764 JSJitInfo_OpType::Method as u8,
9765 JSJitInfo_AliasSet::AliasEverything as u8,
9766 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9767 false,
9768 false,
9769 false,
9770 false,
9771 false,
9772 false,
9773 0,
9774 ).to_ne_bytes()
9775 ),
9776});
9777}
9778unsafe extern "C" fn bufferSubData<D: DomTypes>
9779(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9780 let mut result = false;
9781 wrap_panic(&mut || result = (|| {
9782 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9783 let this = &*(this as *const D::WebGLRenderingContext);
9784 let args = &*args;
9785 let argc = args.argc_;
9786
9787 if argc < 3 {
9788 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.bufferSubData\".");
9789 return false;
9790 }
9791 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9792 Ok(ConversionResult::Success(value)) => value,
9793 Ok(ConversionResult::Failure(error)) => {
9794 throw_type_error(cx.raw_cx(), &error);
9795 return false;
9796
9797 }
9798 _ => {
9799 return false;
9800
9801 },
9802 }
9803 ;
9804 let arg1: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
9805 Ok(ConversionResult::Success(value)) => value,
9806 Ok(ConversionResult::Failure(error)) => {
9807 throw_type_error(cx.raw_cx(), &error);
9808 return false;
9809
9810 }
9811 _ => {
9812 return false;
9813
9814 },
9815 }
9816 ;
9817 let arg2: GenericUnionTypes::ArrayBufferViewOrArrayBuffer = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
9818 Ok(ConversionResult::Success(value)) => value,
9819 Ok(ConversionResult::Failure(error)) => {
9820 throw_type_error(cx.raw_cx(), &error);
9821 return false;
9822
9823 }
9824 _ => {
9825 return false;
9826
9827 },
9828 }
9829 ;
9830 let result: () = this.BufferSubData(arg0, arg1, arg2);
9831
9832 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9833 return true;
9834 })());
9835 result
9836}
9837
9838
9839static bufferSubData_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9840
9841pub(crate) fn init_bufferSubData_methodinfo<D: DomTypes>() {
9842 bufferSubData_methodinfo.set(JSJitInfo {
9843 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9844 method: Some(bufferSubData::<D>)
9845 },
9846 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9847 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9848 },
9849 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9850 _bitfield_align_1: [],
9851 _bitfield_1: __BindgenBitfieldUnit::new(
9852 new_jsjitinfo_bitfield_1!(
9853 JSJitInfo_OpType::Method as u8,
9854 JSJitInfo_AliasSet::AliasEverything as u8,
9855 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
9856 false,
9857 false,
9858 false,
9859 false,
9860 false,
9861 false,
9862 0,
9863 ).to_ne_bytes()
9864 ),
9865});
9866}
9867unsafe extern "C" fn compressedTexImage2D<D: DomTypes>
9868(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9869 let mut result = false;
9870 wrap_panic(&mut || result = (|| {
9871 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9872 let this = &*(this as *const D::WebGLRenderingContext);
9873 let args = &*args;
9874 let argc = args.argc_;
9875
9876 if argc < 7 {
9877 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.compressedTexImage2D\".");
9878 return false;
9879 }
9880 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
9881 Ok(ConversionResult::Success(value)) => value,
9882 Ok(ConversionResult::Failure(error)) => {
9883 throw_type_error(cx.raw_cx(), &error);
9884 return false;
9885
9886 }
9887 _ => {
9888 return false;
9889
9890 },
9891 }
9892 ;
9893 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
9894 Ok(ConversionResult::Success(value)) => value,
9895 Ok(ConversionResult::Failure(error)) => {
9896 throw_type_error(cx.raw_cx(), &error);
9897 return false;
9898
9899 }
9900 _ => {
9901 return false;
9902
9903 },
9904 }
9905 ;
9906 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
9907 Ok(ConversionResult::Success(value)) => value,
9908 Ok(ConversionResult::Failure(error)) => {
9909 throw_type_error(cx.raw_cx(), &error);
9910 return false;
9911
9912 }
9913 _ => {
9914 return false;
9915
9916 },
9917 }
9918 ;
9919 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
9920 Ok(ConversionResult::Success(value)) => value,
9921 Ok(ConversionResult::Failure(error)) => {
9922 throw_type_error(cx.raw_cx(), &error);
9923 return false;
9924
9925 }
9926 _ => {
9927 return false;
9928
9929 },
9930 }
9931 ;
9932 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
9933 Ok(ConversionResult::Success(value)) => value,
9934 Ok(ConversionResult::Failure(error)) => {
9935 throw_type_error(cx.raw_cx(), &error);
9936 return false;
9937
9938 }
9939 _ => {
9940 return false;
9941
9942 },
9943 }
9944 ;
9945 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
9946 Ok(ConversionResult::Success(value)) => value,
9947 Ok(ConversionResult::Failure(error)) => {
9948 throw_type_error(cx.raw_cx(), &error);
9949 return false;
9950
9951 }
9952 _ => {
9953 return false;
9954
9955 },
9956 }
9957 ;
9958 let arg6: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(6)).get().is_object() {
9959 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(6)).get().to_object()) {
9960 Ok(val) => val,
9961 Err(()) => {
9962 throw_type_error(cx.raw_cx(), "value is not a typed array.");
9963 return false;
9964
9965 }
9966 }
9967
9968 } else {
9969 throw_type_error(cx.raw_cx(), "Value is not an object.");
9970 return false;
9971
9972 };
9973 auto_root!(&in(cx) let arg6 = arg6);
9974 let result: () = this.CompressedTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
9975
9976 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9977 return true;
9978 })());
9979 result
9980}
9981
9982
9983static compressedTexImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9984
9985pub(crate) fn init_compressedTexImage2D_methodinfo<D: DomTypes>() {
9986 compressedTexImage2D_methodinfo.set(JSJitInfo {
9987 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9988 method: Some(compressedTexImage2D::<D>)
9989 },
9990 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9991 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
9992 },
9993 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9994 _bitfield_align_1: [],
9995 _bitfield_1: __BindgenBitfieldUnit::new(
9996 new_jsjitinfo_bitfield_1!(
9997 JSJitInfo_OpType::Method as u8,
9998 JSJitInfo_AliasSet::AliasEverything as u8,
9999 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10000 false,
10001 false,
10002 false,
10003 false,
10004 false,
10005 false,
10006 0,
10007 ).to_ne_bytes()
10008 ),
10009});
10010}
10011unsafe extern "C" fn compressedTexSubImage2D<D: DomTypes>
10012(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10013 let mut result = false;
10014 wrap_panic(&mut || result = (|| {
10015 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10016 let this = &*(this as *const D::WebGLRenderingContext);
10017 let args = &*args;
10018 let argc = args.argc_;
10019
10020 if argc < 8 {
10021 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.compressedTexSubImage2D\".");
10022 return false;
10023 }
10024 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
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 arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
10038 Ok(ConversionResult::Success(value)) => value,
10039 Ok(ConversionResult::Failure(error)) => {
10040 throw_type_error(cx.raw_cx(), &error);
10041 return false;
10042
10043 }
10044 _ => {
10045 return false;
10046
10047 },
10048 }
10049 ;
10050 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10051 Ok(ConversionResult::Success(value)) => value,
10052 Ok(ConversionResult::Failure(error)) => {
10053 throw_type_error(cx.raw_cx(), &error);
10054 return false;
10055
10056 }
10057 _ => {
10058 return false;
10059
10060 },
10061 }
10062 ;
10063 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10064 Ok(ConversionResult::Success(value)) => value,
10065 Ok(ConversionResult::Failure(error)) => {
10066 throw_type_error(cx.raw_cx(), &error);
10067 return false;
10068
10069 }
10070 _ => {
10071 return false;
10072
10073 },
10074 }
10075 ;
10076 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10077 Ok(ConversionResult::Success(value)) => value,
10078 Ok(ConversionResult::Failure(error)) => {
10079 throw_type_error(cx.raw_cx(), &error);
10080 return false;
10081
10082 }
10083 _ => {
10084 return false;
10085
10086 },
10087 }
10088 ;
10089 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
10090 Ok(ConversionResult::Success(value)) => value,
10091 Ok(ConversionResult::Failure(error)) => {
10092 throw_type_error(cx.raw_cx(), &error);
10093 return false;
10094
10095 }
10096 _ => {
10097 return false;
10098
10099 },
10100 }
10101 ;
10102 let arg6: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
10103 Ok(ConversionResult::Success(value)) => value,
10104 Ok(ConversionResult::Failure(error)) => {
10105 throw_type_error(cx.raw_cx(), &error);
10106 return false;
10107
10108 }
10109 _ => {
10110 return false;
10111
10112 },
10113 }
10114 ;
10115 let arg7: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(7)).get().is_object() {
10116 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(7)).get().to_object()) {
10117 Ok(val) => val,
10118 Err(()) => {
10119 throw_type_error(cx.raw_cx(), "value is not a typed array.");
10120 return false;
10121
10122 }
10123 }
10124
10125 } else {
10126 throw_type_error(cx.raw_cx(), "Value is not an object.");
10127 return false;
10128
10129 };
10130 auto_root!(&in(cx) let arg7 = arg7);
10131 let result: () = this.CompressedTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
10132
10133 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10134 return true;
10135 })());
10136 result
10137}
10138
10139
10140static compressedTexSubImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10141
10142pub(crate) fn init_compressedTexSubImage2D_methodinfo<D: DomTypes>() {
10143 compressedTexSubImage2D_methodinfo.set(JSJitInfo {
10144 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10145 method: Some(compressedTexSubImage2D::<D>)
10146 },
10147 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10148 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
10149 },
10150 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10151 _bitfield_align_1: [],
10152 _bitfield_1: __BindgenBitfieldUnit::new(
10153 new_jsjitinfo_bitfield_1!(
10154 JSJitInfo_OpType::Method as u8,
10155 JSJitInfo_AliasSet::AliasEverything as u8,
10156 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10157 false,
10158 false,
10159 false,
10160 false,
10161 false,
10162 false,
10163 0,
10164 ).to_ne_bytes()
10165 ),
10166});
10167}
10168unsafe extern "C" fn readPixels<D: DomTypes>
10169(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10170 let mut result = false;
10171 wrap_panic(&mut || result = (|| {
10172 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10173 let this = &*(this as *const D::WebGLRenderingContext);
10174 let args = &*args;
10175 let argc = args.argc_;
10176
10177 if argc < 7 {
10178 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.readPixels\".");
10179 return false;
10180 }
10181 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
10182 Ok(ConversionResult::Success(value)) => value,
10183 Ok(ConversionResult::Failure(error)) => {
10184 throw_type_error(cx.raw_cx(), &error);
10185 return false;
10186
10187 }
10188 _ => {
10189 return false;
10190
10191 },
10192 }
10193 ;
10194 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
10195 Ok(ConversionResult::Success(value)) => value,
10196 Ok(ConversionResult::Failure(error)) => {
10197 throw_type_error(cx.raw_cx(), &error);
10198 return false;
10199
10200 }
10201 _ => {
10202 return false;
10203
10204 },
10205 }
10206 ;
10207 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10208 Ok(ConversionResult::Success(value)) => value,
10209 Ok(ConversionResult::Failure(error)) => {
10210 throw_type_error(cx.raw_cx(), &error);
10211 return false;
10212
10213 }
10214 _ => {
10215 return false;
10216
10217 },
10218 }
10219 ;
10220 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10221 Ok(ConversionResult::Success(value)) => value,
10222 Ok(ConversionResult::Failure(error)) => {
10223 throw_type_error(cx.raw_cx(), &error);
10224 return false;
10225
10226 }
10227 _ => {
10228 return false;
10229
10230 },
10231 }
10232 ;
10233 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10234 Ok(ConversionResult::Success(value)) => value,
10235 Ok(ConversionResult::Failure(error)) => {
10236 throw_type_error(cx.raw_cx(), &error);
10237 return false;
10238
10239 }
10240 _ => {
10241 return false;
10242
10243 },
10244 }
10245 ;
10246 let arg5: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
10247 Ok(ConversionResult::Success(value)) => value,
10248 Ok(ConversionResult::Failure(error)) => {
10249 throw_type_error(cx.raw_cx(), &error);
10250 return false;
10251
10252 }
10253 _ => {
10254 return false;
10255
10256 },
10257 }
10258 ;
10259 let arg6: Option<typedarray::ArrayBufferView> = if HandleValue::from_raw(args.get(6)).get().is_object() {
10260 Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(6)).get().to_object()) {
10261 Ok(val) => val,
10262 Err(()) => {
10263 throw_type_error(cx.raw_cx(), "value is not a typed array.");
10264 return false;
10265
10266 }
10267 }
10268 )
10269 } else if HandleValue::from_raw(args.get(6)).get().is_null_or_undefined() {
10270 None
10271 } else {
10272 throw_type_error(cx.raw_cx(), "Value is not an object.");
10273 return false;
10274
10275 };
10276 auto_root!(&in(cx) let arg6 = arg6);
10277 let result: () = this.ReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
10278
10279 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10280 return true;
10281 })());
10282 result
10283}
10284
10285
10286static readPixels_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10287
10288pub(crate) fn init_readPixels_methodinfo<D: DomTypes>() {
10289 readPixels_methodinfo.set(JSJitInfo {
10290 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10291 method: Some(readPixels::<D>)
10292 },
10293 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10294 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
10295 },
10296 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10297 _bitfield_align_1: [],
10298 _bitfield_1: __BindgenBitfieldUnit::new(
10299 new_jsjitinfo_bitfield_1!(
10300 JSJitInfo_OpType::Method as u8,
10301 JSJitInfo_AliasSet::AliasEverything as u8,
10302 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10303 false,
10304 false,
10305 false,
10306 false,
10307 false,
10308 false,
10309 0,
10310 ).to_ne_bytes()
10311 ),
10312});
10313}
10314unsafe extern "C" fn texImage2D<D: DomTypes>
10315(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10316 let mut result = false;
10317 wrap_panic(&mut || result = (|| {
10318 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10319 let this = &*(this as *const D::WebGLRenderingContext);
10320 let args = &*args;
10321 let argc = args.argc_;
10322
10323 let argcount = cmp::min(argc, 9);
10324 match argcount {
10325 6 => {
10326 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
10327 Ok(ConversionResult::Success(value)) => value,
10328 Ok(ConversionResult::Failure(error)) => {
10329 throw_type_error(cx.raw_cx(), &error);
10330 return false;
10331
10332 }
10333 _ => {
10334 return false;
10335
10336 },
10337 }
10338 ;
10339 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
10340 Ok(ConversionResult::Success(value)) => value,
10341 Ok(ConversionResult::Failure(error)) => {
10342 throw_type_error(cx.raw_cx(), &error);
10343 return false;
10344
10345 }
10346 _ => {
10347 return false;
10348
10349 },
10350 }
10351 ;
10352 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10353 Ok(ConversionResult::Success(value)) => value,
10354 Ok(ConversionResult::Failure(error)) => {
10355 throw_type_error(cx.raw_cx(), &error);
10356 return false;
10357
10358 }
10359 _ => {
10360 return false;
10361
10362 },
10363 }
10364 ;
10365 let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10366 Ok(ConversionResult::Success(value)) => value,
10367 Ok(ConversionResult::Failure(error)) => {
10368 throw_type_error(cx.raw_cx(), &error);
10369 return false;
10370
10371 }
10372 _ => {
10373 return false;
10374
10375 },
10376 }
10377 ;
10378 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10379 Ok(ConversionResult::Success(value)) => value,
10380 Ok(ConversionResult::Failure(error)) => {
10381 throw_type_error(cx.raw_cx(), &error);
10382 return false;
10383
10384 }
10385 _ => {
10386 return false;
10387
10388 },
10389 }
10390 ;
10391 let arg5: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ()) {
10392 Ok(ConversionResult::Success(value)) => value,
10393 Ok(ConversionResult::Failure(error)) => {
10394 throw_type_error(cx.raw_cx(), &error);
10395 return false;
10396
10397 }
10398 _ => {
10399 return false;
10400
10401 },
10402 }
10403 ;
10404 let result: Result<(), Error> = this.TexImage2D_(arg0, arg1, arg2, arg3, arg4, arg5);
10405 let result = match result {
10406 Ok(result) => result,
10407 Err(e) => {
10408 <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());
10409 return false;
10410 },
10411 };
10412
10413 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10414 return true;
10415 }
10416 9 => {
10417 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
10418 Ok(ConversionResult::Success(value)) => value,
10419 Ok(ConversionResult::Failure(error)) => {
10420 throw_type_error(cx.raw_cx(), &error);
10421 return false;
10422
10423 }
10424 _ => {
10425 return false;
10426
10427 },
10428 }
10429 ;
10430 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
10431 Ok(ConversionResult::Success(value)) => value,
10432 Ok(ConversionResult::Failure(error)) => {
10433 throw_type_error(cx.raw_cx(), &error);
10434 return false;
10435
10436 }
10437 _ => {
10438 return false;
10439
10440 },
10441 }
10442 ;
10443 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10444 Ok(ConversionResult::Success(value)) => value,
10445 Ok(ConversionResult::Failure(error)) => {
10446 throw_type_error(cx.raw_cx(), &error);
10447 return false;
10448
10449 }
10450 _ => {
10451 return false;
10452
10453 },
10454 }
10455 ;
10456 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10457 Ok(ConversionResult::Success(value)) => value,
10458 Ok(ConversionResult::Failure(error)) => {
10459 throw_type_error(cx.raw_cx(), &error);
10460 return false;
10461
10462 }
10463 _ => {
10464 return false;
10465
10466 },
10467 }
10468 ;
10469 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10470 Ok(ConversionResult::Success(value)) => value,
10471 Ok(ConversionResult::Failure(error)) => {
10472 throw_type_error(cx.raw_cx(), &error);
10473 return false;
10474
10475 }
10476 _ => {
10477 return false;
10478
10479 },
10480 }
10481 ;
10482 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
10483 Ok(ConversionResult::Success(value)) => value,
10484 Ok(ConversionResult::Failure(error)) => {
10485 throw_type_error(cx.raw_cx(), &error);
10486 return false;
10487
10488 }
10489 _ => {
10490 return false;
10491
10492 },
10493 }
10494 ;
10495 let arg6: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
10496 Ok(ConversionResult::Success(value)) => value,
10497 Ok(ConversionResult::Failure(error)) => {
10498 throw_type_error(cx.raw_cx(), &error);
10499 return false;
10500
10501 }
10502 _ => {
10503 return false;
10504
10505 },
10506 }
10507 ;
10508 let arg7: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
10509 Ok(ConversionResult::Success(value)) => value,
10510 Ok(ConversionResult::Failure(error)) => {
10511 throw_type_error(cx.raw_cx(), &error);
10512 return false;
10513
10514 }
10515 _ => {
10516 return false;
10517
10518 },
10519 }
10520 ;
10521 let arg8: Option<typedarray::ArrayBufferView> = if HandleValue::from_raw(args.get(8)).get().is_object() {
10522 Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(8)).get().to_object()) {
10523 Ok(val) => val,
10524 Err(()) => {
10525 throw_type_error(cx.raw_cx(), "value is not a typed array.");
10526 return false;
10527
10528 }
10529 }
10530 )
10531 } else if HandleValue::from_raw(args.get(8)).get().is_null_or_undefined() {
10532 None
10533 } else {
10534 throw_type_error(cx.raw_cx(), "Value is not an object.");
10535 return false;
10536
10537 };
10538 auto_root!(&in(cx) let arg8 = arg8);
10539 let result: Result<(), Error> = this.TexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
10540 let result = match result {
10541 Ok(result) => result,
10542 Err(e) => {
10543 <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());
10544 return false;
10545 },
10546 };
10547
10548 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10549 return true;
10550 }
10551 _ => {
10552 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.texImage2D\".");
10553 return false;
10554 }
10555 }
10556 })());
10557 result
10558}
10559
10560
10561static texImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10562
10563pub(crate) fn init_texImage2D_methodinfo<D: DomTypes>() {
10564 texImage2D_methodinfo.set(JSJitInfo {
10565 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10566 method: Some(texImage2D::<D>)
10567 },
10568 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10569 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
10570 },
10571 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10572 _bitfield_align_1: [],
10573 _bitfield_1: __BindgenBitfieldUnit::new(
10574 new_jsjitinfo_bitfield_1!(
10575 JSJitInfo_OpType::Method as u8,
10576 JSJitInfo_AliasSet::AliasEverything as u8,
10577 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10578 false,
10579 false,
10580 false,
10581 false,
10582 false,
10583 false,
10584 0,
10585 ).to_ne_bytes()
10586 ),
10587});
10588}
10589unsafe extern "C" fn texSubImage2D<D: DomTypes>
10590(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10591 let mut result = false;
10592 wrap_panic(&mut || result = (|| {
10593 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10594 let this = &*(this as *const D::WebGLRenderingContext);
10595 let args = &*args;
10596 let argc = args.argc_;
10597
10598 let argcount = cmp::min(argc, 9);
10599 match argcount {
10600 7 => {
10601 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
10602 Ok(ConversionResult::Success(value)) => value,
10603 Ok(ConversionResult::Failure(error)) => {
10604 throw_type_error(cx.raw_cx(), &error);
10605 return false;
10606
10607 }
10608 _ => {
10609 return false;
10610
10611 },
10612 }
10613 ;
10614 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
10615 Ok(ConversionResult::Success(value)) => value,
10616 Ok(ConversionResult::Failure(error)) => {
10617 throw_type_error(cx.raw_cx(), &error);
10618 return false;
10619
10620 }
10621 _ => {
10622 return false;
10623
10624 },
10625 }
10626 ;
10627 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10628 Ok(ConversionResult::Success(value)) => value,
10629 Ok(ConversionResult::Failure(error)) => {
10630 throw_type_error(cx.raw_cx(), &error);
10631 return false;
10632
10633 }
10634 _ => {
10635 return false;
10636
10637 },
10638 }
10639 ;
10640 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10641 Ok(ConversionResult::Success(value)) => value,
10642 Ok(ConversionResult::Failure(error)) => {
10643 throw_type_error(cx.raw_cx(), &error);
10644 return false;
10645
10646 }
10647 _ => {
10648 return false;
10649
10650 },
10651 }
10652 ;
10653 let arg4: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10654 Ok(ConversionResult::Success(value)) => value,
10655 Ok(ConversionResult::Failure(error)) => {
10656 throw_type_error(cx.raw_cx(), &error);
10657 return false;
10658
10659 }
10660 _ => {
10661 return false;
10662
10663 },
10664 }
10665 ;
10666 let arg5: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), 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 let arg6: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ()) {
10680 Ok(ConversionResult::Success(value)) => value,
10681 Ok(ConversionResult::Failure(error)) => {
10682 throw_type_error(cx.raw_cx(), &error);
10683 return false;
10684
10685 }
10686 _ => {
10687 return false;
10688
10689 },
10690 }
10691 ;
10692 let result: Result<(), Error> = this.TexSubImage2D_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
10693 let result = match result {
10694 Ok(result) => result,
10695 Err(e) => {
10696 <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());
10697 return false;
10698 },
10699 };
10700
10701 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10702 return true;
10703 }
10704 9 => {
10705 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
10706 Ok(ConversionResult::Success(value)) => value,
10707 Ok(ConversionResult::Failure(error)) => {
10708 throw_type_error(cx.raw_cx(), &error);
10709 return false;
10710
10711 }
10712 _ => {
10713 return false;
10714
10715 },
10716 }
10717 ;
10718 let arg1: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
10719 Ok(ConversionResult::Success(value)) => value,
10720 Ok(ConversionResult::Failure(error)) => {
10721 throw_type_error(cx.raw_cx(), &error);
10722 return false;
10723
10724 }
10725 _ => {
10726 return false;
10727
10728 },
10729 }
10730 ;
10731 let arg2: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
10732 Ok(ConversionResult::Success(value)) => value,
10733 Ok(ConversionResult::Failure(error)) => {
10734 throw_type_error(cx.raw_cx(), &error);
10735 return false;
10736
10737 }
10738 _ => {
10739 return false;
10740
10741 },
10742 }
10743 ;
10744 let arg3: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::Default) {
10745 Ok(ConversionResult::Success(value)) => value,
10746 Ok(ConversionResult::Failure(error)) => {
10747 throw_type_error(cx.raw_cx(), &error);
10748 return false;
10749
10750 }
10751 _ => {
10752 return false;
10753
10754 },
10755 }
10756 ;
10757 let arg4: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::Default) {
10758 Ok(ConversionResult::Success(value)) => value,
10759 Ok(ConversionResult::Failure(error)) => {
10760 throw_type_error(cx.raw_cx(), &error);
10761 return false;
10762
10763 }
10764 _ => {
10765 return false;
10766
10767 },
10768 }
10769 ;
10770 let arg5: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ConversionBehavior::Default) {
10771 Ok(ConversionResult::Success(value)) => value,
10772 Ok(ConversionResult::Failure(error)) => {
10773 throw_type_error(cx.raw_cx(), &error);
10774 return false;
10775
10776 }
10777 _ => {
10778 return false;
10779
10780 },
10781 }
10782 ;
10783 let arg6: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(6)), ConversionBehavior::Default) {
10784 Ok(ConversionResult::Success(value)) => value,
10785 Ok(ConversionResult::Failure(error)) => {
10786 throw_type_error(cx.raw_cx(), &error);
10787 return false;
10788
10789 }
10790 _ => {
10791 return false;
10792
10793 },
10794 }
10795 ;
10796 let arg7: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(7)), ConversionBehavior::Default) {
10797 Ok(ConversionResult::Success(value)) => value,
10798 Ok(ConversionResult::Failure(error)) => {
10799 throw_type_error(cx.raw_cx(), &error);
10800 return false;
10801
10802 }
10803 _ => {
10804 return false;
10805
10806 },
10807 }
10808 ;
10809 let arg8: Option<typedarray::ArrayBufferView> = if HandleValue::from_raw(args.get(8)).get().is_object() {
10810 Some(match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(8)).get().to_object()) {
10811 Ok(val) => val,
10812 Err(()) => {
10813 throw_type_error(cx.raw_cx(), "value is not a typed array.");
10814 return false;
10815
10816 }
10817 }
10818 )
10819 } else if HandleValue::from_raw(args.get(8)).get().is_null_or_undefined() {
10820 None
10821 } else {
10822 throw_type_error(cx.raw_cx(), "Value is not an object.");
10823 return false;
10824
10825 };
10826 auto_root!(&in(cx) let arg8 = arg8);
10827 let result: Result<(), Error> = this.TexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
10828 let result = match result {
10829 Ok(result) => result,
10830 Err(e) => {
10831 <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());
10832 return false;
10833 },
10834 };
10835
10836 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10837 return true;
10838 }
10839 _ => {
10840 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.texSubImage2D\".");
10841 return false;
10842 }
10843 }
10844 })());
10845 result
10846}
10847
10848
10849static texSubImage2D_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10850
10851pub(crate) fn init_texSubImage2D_methodinfo<D: DomTypes>() {
10852 texSubImage2D_methodinfo.set(JSJitInfo {
10853 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10854 method: Some(texSubImage2D::<D>)
10855 },
10856 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10857 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
10858 },
10859 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10860 _bitfield_align_1: [],
10861 _bitfield_1: __BindgenBitfieldUnit::new(
10862 new_jsjitinfo_bitfield_1!(
10863 JSJitInfo_OpType::Method as u8,
10864 JSJitInfo_AliasSet::AliasEverything as u8,
10865 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10866 false,
10867 false,
10868 false,
10869 false,
10870 false,
10871 false,
10872 0,
10873 ).to_ne_bytes()
10874 ),
10875});
10876}
10877unsafe extern "C" fn uniform1fv<D: DomTypes>
10878(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10879 let mut result = false;
10880 wrap_panic(&mut || result = (|| {
10881 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10882 let this = &*(this as *const D::WebGLRenderingContext);
10883 let args = &*args;
10884 let argc = args.argc_;
10885
10886 if argc < 2 {
10887 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform1fv\".");
10888 return false;
10889 }
10890 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10891 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
10892 Ok(val) => val,
10893 Err(()) => {
10894 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
10895 return false;
10896
10897 }
10898 }
10899 )
10900 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
10901 None
10902 } else {
10903 throw_type_error(cx.raw_cx(), "Value is not an object.");
10904 return false;
10905
10906 };
10907 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
10908 Ok(ConversionResult::Success(value)) => value,
10909 Ok(ConversionResult::Failure(error)) => {
10910 throw_type_error(cx.raw_cx(), &error);
10911 return false;
10912
10913 }
10914 _ => {
10915 return false;
10916
10917 },
10918 }
10919 ;
10920 let result: () = this.Uniform1fv(arg0.as_deref(), arg1);
10921
10922 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10923 return true;
10924 })());
10925 result
10926}
10927
10928
10929static uniform1fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10930
10931pub(crate) fn init_uniform1fv_methodinfo<D: DomTypes>() {
10932 uniform1fv_methodinfo.set(JSJitInfo {
10933 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10934 method: Some(uniform1fv::<D>)
10935 },
10936 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10937 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
10938 },
10939 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10940 _bitfield_align_1: [],
10941 _bitfield_1: __BindgenBitfieldUnit::new(
10942 new_jsjitinfo_bitfield_1!(
10943 JSJitInfo_OpType::Method as u8,
10944 JSJitInfo_AliasSet::AliasEverything as u8,
10945 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
10946 false,
10947 false,
10948 false,
10949 false,
10950 false,
10951 false,
10952 0,
10953 ).to_ne_bytes()
10954 ),
10955});
10956}
10957unsafe extern "C" fn uniform2fv<D: DomTypes>
10958(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10959 let mut result = false;
10960 wrap_panic(&mut || result = (|| {
10961 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10962 let this = &*(this as *const D::WebGLRenderingContext);
10963 let args = &*args;
10964 let argc = args.argc_;
10965
10966 if argc < 2 {
10967 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform2fv\".");
10968 return false;
10969 }
10970 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
10971 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
10972 Ok(val) => val,
10973 Err(()) => {
10974 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
10975 return false;
10976
10977 }
10978 }
10979 )
10980 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
10981 None
10982 } else {
10983 throw_type_error(cx.raw_cx(), "Value is not an object.");
10984 return false;
10985
10986 };
10987 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
10988 Ok(ConversionResult::Success(value)) => value,
10989 Ok(ConversionResult::Failure(error)) => {
10990 throw_type_error(cx.raw_cx(), &error);
10991 return false;
10992
10993 }
10994 _ => {
10995 return false;
10996
10997 },
10998 }
10999 ;
11000 let result: () = this.Uniform2fv(arg0.as_deref(), arg1);
11001
11002 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11003 return true;
11004 })());
11005 result
11006}
11007
11008
11009static uniform2fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11010
11011pub(crate) fn init_uniform2fv_methodinfo<D: DomTypes>() {
11012 uniform2fv_methodinfo.set(JSJitInfo {
11013 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11014 method: Some(uniform2fv::<D>)
11015 },
11016 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11017 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11018 },
11019 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11020 _bitfield_align_1: [],
11021 _bitfield_1: __BindgenBitfieldUnit::new(
11022 new_jsjitinfo_bitfield_1!(
11023 JSJitInfo_OpType::Method as u8,
11024 JSJitInfo_AliasSet::AliasEverything as u8,
11025 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11026 false,
11027 false,
11028 false,
11029 false,
11030 false,
11031 false,
11032 0,
11033 ).to_ne_bytes()
11034 ),
11035});
11036}
11037unsafe extern "C" fn uniform3fv<D: DomTypes>
11038(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11039 let mut result = false;
11040 wrap_panic(&mut || result = (|| {
11041 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11042 let this = &*(this as *const D::WebGLRenderingContext);
11043 let args = &*args;
11044 let argc = args.argc_;
11045
11046 if argc < 2 {
11047 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform3fv\".");
11048 return false;
11049 }
11050 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11051 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11052 Ok(val) => val,
11053 Err(()) => {
11054 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11055 return false;
11056
11057 }
11058 }
11059 )
11060 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11061 None
11062 } else {
11063 throw_type_error(cx.raw_cx(), "Value is not an object.");
11064 return false;
11065
11066 };
11067 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11068 Ok(ConversionResult::Success(value)) => value,
11069 Ok(ConversionResult::Failure(error)) => {
11070 throw_type_error(cx.raw_cx(), &error);
11071 return false;
11072
11073 }
11074 _ => {
11075 return false;
11076
11077 },
11078 }
11079 ;
11080 let result: () = this.Uniform3fv(arg0.as_deref(), arg1);
11081
11082 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11083 return true;
11084 })());
11085 result
11086}
11087
11088
11089static uniform3fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11090
11091pub(crate) fn init_uniform3fv_methodinfo<D: DomTypes>() {
11092 uniform3fv_methodinfo.set(JSJitInfo {
11093 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11094 method: Some(uniform3fv::<D>)
11095 },
11096 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11097 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11098 },
11099 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11100 _bitfield_align_1: [],
11101 _bitfield_1: __BindgenBitfieldUnit::new(
11102 new_jsjitinfo_bitfield_1!(
11103 JSJitInfo_OpType::Method as u8,
11104 JSJitInfo_AliasSet::AliasEverything as u8,
11105 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11106 false,
11107 false,
11108 false,
11109 false,
11110 false,
11111 false,
11112 0,
11113 ).to_ne_bytes()
11114 ),
11115});
11116}
11117unsafe extern "C" fn uniform4fv<D: DomTypes>
11118(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11119 let mut result = false;
11120 wrap_panic(&mut || result = (|| {
11121 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11122 let this = &*(this as *const D::WebGLRenderingContext);
11123 let args = &*args;
11124 let argc = args.argc_;
11125
11126 if argc < 2 {
11127 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform4fv\".");
11128 return false;
11129 }
11130 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11131 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11132 Ok(val) => val,
11133 Err(()) => {
11134 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11135 return false;
11136
11137 }
11138 }
11139 )
11140 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11141 None
11142 } else {
11143 throw_type_error(cx.raw_cx(), "Value is not an object.");
11144 return false;
11145
11146 };
11147 let arg1: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11148 Ok(ConversionResult::Success(value)) => value,
11149 Ok(ConversionResult::Failure(error)) => {
11150 throw_type_error(cx.raw_cx(), &error);
11151 return false;
11152
11153 }
11154 _ => {
11155 return false;
11156
11157 },
11158 }
11159 ;
11160 let result: () = this.Uniform4fv(arg0.as_deref(), arg1);
11161
11162 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11163 return true;
11164 })());
11165 result
11166}
11167
11168
11169static uniform4fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11170
11171pub(crate) fn init_uniform4fv_methodinfo<D: DomTypes>() {
11172 uniform4fv_methodinfo.set(JSJitInfo {
11173 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11174 method: Some(uniform4fv::<D>)
11175 },
11176 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11177 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11178 },
11179 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11180 _bitfield_align_1: [],
11181 _bitfield_1: __BindgenBitfieldUnit::new(
11182 new_jsjitinfo_bitfield_1!(
11183 JSJitInfo_OpType::Method as u8,
11184 JSJitInfo_AliasSet::AliasEverything as u8,
11185 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11186 false,
11187 false,
11188 false,
11189 false,
11190 false,
11191 false,
11192 0,
11193 ).to_ne_bytes()
11194 ),
11195});
11196}
11197unsafe extern "C" fn uniform1iv<D: DomTypes>
11198(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11199 let mut result = false;
11200 wrap_panic(&mut || result = (|| {
11201 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11202 let this = &*(this as *const D::WebGLRenderingContext);
11203 let args = &*args;
11204 let argc = args.argc_;
11205
11206 if argc < 2 {
11207 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform1iv\".");
11208 return false;
11209 }
11210 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11211 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11212 Ok(val) => val,
11213 Err(()) => {
11214 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11215 return false;
11216
11217 }
11218 }
11219 )
11220 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11221 None
11222 } else {
11223 throw_type_error(cx.raw_cx(), "Value is not an object.");
11224 return false;
11225
11226 };
11227 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11228 Ok(ConversionResult::Success(value)) => value,
11229 Ok(ConversionResult::Failure(error)) => {
11230 throw_type_error(cx.raw_cx(), &error);
11231 return false;
11232
11233 }
11234 _ => {
11235 return false;
11236
11237 },
11238 }
11239 ;
11240 let result: () = this.Uniform1iv(arg0.as_deref(), arg1);
11241
11242 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11243 return true;
11244 })());
11245 result
11246}
11247
11248
11249static uniform1iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11250
11251pub(crate) fn init_uniform1iv_methodinfo<D: DomTypes>() {
11252 uniform1iv_methodinfo.set(JSJitInfo {
11253 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11254 method: Some(uniform1iv::<D>)
11255 },
11256 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11257 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11258 },
11259 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11260 _bitfield_align_1: [],
11261 _bitfield_1: __BindgenBitfieldUnit::new(
11262 new_jsjitinfo_bitfield_1!(
11263 JSJitInfo_OpType::Method as u8,
11264 JSJitInfo_AliasSet::AliasEverything as u8,
11265 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11266 false,
11267 false,
11268 false,
11269 false,
11270 false,
11271 false,
11272 0,
11273 ).to_ne_bytes()
11274 ),
11275});
11276}
11277unsafe extern "C" fn uniform2iv<D: DomTypes>
11278(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11279 let mut result = false;
11280 wrap_panic(&mut || result = (|| {
11281 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11282 let this = &*(this as *const D::WebGLRenderingContext);
11283 let args = &*args;
11284 let argc = args.argc_;
11285
11286 if argc < 2 {
11287 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform2iv\".");
11288 return false;
11289 }
11290 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11291 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11292 Ok(val) => val,
11293 Err(()) => {
11294 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11295 return false;
11296
11297 }
11298 }
11299 )
11300 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11301 None
11302 } else {
11303 throw_type_error(cx.raw_cx(), "Value is not an object.");
11304 return false;
11305
11306 };
11307 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11308 Ok(ConversionResult::Success(value)) => value,
11309 Ok(ConversionResult::Failure(error)) => {
11310 throw_type_error(cx.raw_cx(), &error);
11311 return false;
11312
11313 }
11314 _ => {
11315 return false;
11316
11317 },
11318 }
11319 ;
11320 let result: () = this.Uniform2iv(arg0.as_deref(), arg1);
11321
11322 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11323 return true;
11324 })());
11325 result
11326}
11327
11328
11329static uniform2iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11330
11331pub(crate) fn init_uniform2iv_methodinfo<D: DomTypes>() {
11332 uniform2iv_methodinfo.set(JSJitInfo {
11333 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11334 method: Some(uniform2iv::<D>)
11335 },
11336 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11337 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11338 },
11339 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11340 _bitfield_align_1: [],
11341 _bitfield_1: __BindgenBitfieldUnit::new(
11342 new_jsjitinfo_bitfield_1!(
11343 JSJitInfo_OpType::Method as u8,
11344 JSJitInfo_AliasSet::AliasEverything as u8,
11345 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11346 false,
11347 false,
11348 false,
11349 false,
11350 false,
11351 false,
11352 0,
11353 ).to_ne_bytes()
11354 ),
11355});
11356}
11357unsafe extern "C" fn uniform3iv<D: DomTypes>
11358(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11359 let mut result = false;
11360 wrap_panic(&mut || result = (|| {
11361 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11362 let this = &*(this as *const D::WebGLRenderingContext);
11363 let args = &*args;
11364 let argc = args.argc_;
11365
11366 if argc < 2 {
11367 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform3iv\".");
11368 return false;
11369 }
11370 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11371 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11372 Ok(val) => val,
11373 Err(()) => {
11374 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11375 return false;
11376
11377 }
11378 }
11379 )
11380 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11381 None
11382 } else {
11383 throw_type_error(cx.raw_cx(), "Value is not an object.");
11384 return false;
11385
11386 };
11387 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11388 Ok(ConversionResult::Success(value)) => value,
11389 Ok(ConversionResult::Failure(error)) => {
11390 throw_type_error(cx.raw_cx(), &error);
11391 return false;
11392
11393 }
11394 _ => {
11395 return false;
11396
11397 },
11398 }
11399 ;
11400 let result: () = this.Uniform3iv(arg0.as_deref(), arg1);
11401
11402 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11403 return true;
11404 })());
11405 result
11406}
11407
11408
11409static uniform3iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11410
11411pub(crate) fn init_uniform3iv_methodinfo<D: DomTypes>() {
11412 uniform3iv_methodinfo.set(JSJitInfo {
11413 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11414 method: Some(uniform3iv::<D>)
11415 },
11416 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11417 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11418 },
11419 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11420 _bitfield_align_1: [],
11421 _bitfield_1: __BindgenBitfieldUnit::new(
11422 new_jsjitinfo_bitfield_1!(
11423 JSJitInfo_OpType::Method as u8,
11424 JSJitInfo_AliasSet::AliasEverything as u8,
11425 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11426 false,
11427 false,
11428 false,
11429 false,
11430 false,
11431 false,
11432 0,
11433 ).to_ne_bytes()
11434 ),
11435});
11436}
11437unsafe extern "C" fn uniform4iv<D: DomTypes>
11438(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11439 let mut result = false;
11440 wrap_panic(&mut || result = (|| {
11441 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11442 let this = &*(this as *const D::WebGLRenderingContext);
11443 let args = &*args;
11444 let argc = args.argc_;
11445
11446 if argc < 2 {
11447 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniform4iv\".");
11448 return false;
11449 }
11450 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11451 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11452 Ok(val) => val,
11453 Err(()) => {
11454 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11455 return false;
11456
11457 }
11458 }
11459 )
11460 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11461 None
11462 } else {
11463 throw_type_error(cx.raw_cx(), "Value is not an object.");
11464 return false;
11465
11466 };
11467 let arg1: GenericUnionTypes::Int32ArrayOrLongSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11468 Ok(ConversionResult::Success(value)) => value,
11469 Ok(ConversionResult::Failure(error)) => {
11470 throw_type_error(cx.raw_cx(), &error);
11471 return false;
11472
11473 }
11474 _ => {
11475 return false;
11476
11477 },
11478 }
11479 ;
11480 let result: () = this.Uniform4iv(arg0.as_deref(), arg1);
11481
11482 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11483 return true;
11484 })());
11485 result
11486}
11487
11488
11489static uniform4iv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11490
11491pub(crate) fn init_uniform4iv_methodinfo<D: DomTypes>() {
11492 uniform4iv_methodinfo.set(JSJitInfo {
11493 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11494 method: Some(uniform4iv::<D>)
11495 },
11496 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11497 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11498 },
11499 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11500 _bitfield_align_1: [],
11501 _bitfield_1: __BindgenBitfieldUnit::new(
11502 new_jsjitinfo_bitfield_1!(
11503 JSJitInfo_OpType::Method as u8,
11504 JSJitInfo_AliasSet::AliasEverything as u8,
11505 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11506 false,
11507 false,
11508 false,
11509 false,
11510 false,
11511 false,
11512 0,
11513 ).to_ne_bytes()
11514 ),
11515});
11516}
11517unsafe extern "C" fn uniformMatrix2fv<D: DomTypes>
11518(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11519 let mut result = false;
11520 wrap_panic(&mut || result = (|| {
11521 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11522 let this = &*(this as *const D::WebGLRenderingContext);
11523 let args = &*args;
11524 let argc = args.argc_;
11525
11526 if argc < 3 {
11527 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniformMatrix2fv\".");
11528 return false;
11529 }
11530 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11531 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11532 Ok(val) => val,
11533 Err(()) => {
11534 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11535 return false;
11536
11537 }
11538 }
11539 )
11540 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11541 None
11542 } else {
11543 throw_type_error(cx.raw_cx(), "Value is not an object.");
11544 return false;
11545
11546 };
11547 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11548 Ok(ConversionResult::Success(value)) => value,
11549 Ok(ConversionResult::Failure(error)) => {
11550 throw_type_error(cx.raw_cx(), &error);
11551 return false;
11552
11553 }
11554 _ => {
11555 return false;
11556
11557 },
11558 }
11559 ;
11560 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
11561 Ok(ConversionResult::Success(value)) => value,
11562 Ok(ConversionResult::Failure(error)) => {
11563 throw_type_error(cx.raw_cx(), &error);
11564 return false;
11565
11566 }
11567 _ => {
11568 return false;
11569
11570 },
11571 }
11572 ;
11573 let result: () = this.UniformMatrix2fv(arg0.as_deref(), arg1, arg2);
11574
11575 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11576 return true;
11577 })());
11578 result
11579}
11580
11581
11582static uniformMatrix2fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11583
11584pub(crate) fn init_uniformMatrix2fv_methodinfo<D: DomTypes>() {
11585 uniformMatrix2fv_methodinfo.set(JSJitInfo {
11586 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11587 method: Some(uniformMatrix2fv::<D>)
11588 },
11589 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11590 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11591 },
11592 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11593 _bitfield_align_1: [],
11594 _bitfield_1: __BindgenBitfieldUnit::new(
11595 new_jsjitinfo_bitfield_1!(
11596 JSJitInfo_OpType::Method as u8,
11597 JSJitInfo_AliasSet::AliasEverything as u8,
11598 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11599 false,
11600 false,
11601 false,
11602 false,
11603 false,
11604 false,
11605 0,
11606 ).to_ne_bytes()
11607 ),
11608});
11609}
11610unsafe extern "C" fn uniformMatrix3fv<D: DomTypes>
11611(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11612 let mut result = false;
11613 wrap_panic(&mut || result = (|| {
11614 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11615 let this = &*(this as *const D::WebGLRenderingContext);
11616 let args = &*args;
11617 let argc = args.argc_;
11618
11619 if argc < 3 {
11620 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniformMatrix3fv\".");
11621 return false;
11622 }
11623 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11624 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11625 Ok(val) => val,
11626 Err(()) => {
11627 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11628 return false;
11629
11630 }
11631 }
11632 )
11633 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11634 None
11635 } else {
11636 throw_type_error(cx.raw_cx(), "Value is not an object.");
11637 return false;
11638
11639 };
11640 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11641 Ok(ConversionResult::Success(value)) => value,
11642 Ok(ConversionResult::Failure(error)) => {
11643 throw_type_error(cx.raw_cx(), &error);
11644 return false;
11645
11646 }
11647 _ => {
11648 return false;
11649
11650 },
11651 }
11652 ;
11653 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
11654 Ok(ConversionResult::Success(value)) => value,
11655 Ok(ConversionResult::Failure(error)) => {
11656 throw_type_error(cx.raw_cx(), &error);
11657 return false;
11658
11659 }
11660 _ => {
11661 return false;
11662
11663 },
11664 }
11665 ;
11666 let result: () = this.UniformMatrix3fv(arg0.as_deref(), arg1, arg2);
11667
11668 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11669 return true;
11670 })());
11671 result
11672}
11673
11674
11675static uniformMatrix3fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11676
11677pub(crate) fn init_uniformMatrix3fv_methodinfo<D: DomTypes>() {
11678 uniformMatrix3fv_methodinfo.set(JSJitInfo {
11679 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11680 method: Some(uniformMatrix3fv::<D>)
11681 },
11682 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11683 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11684 },
11685 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11686 _bitfield_align_1: [],
11687 _bitfield_1: __BindgenBitfieldUnit::new(
11688 new_jsjitinfo_bitfield_1!(
11689 JSJitInfo_OpType::Method as u8,
11690 JSJitInfo_AliasSet::AliasEverything as u8,
11691 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11692 false,
11693 false,
11694 false,
11695 false,
11696 false,
11697 false,
11698 0,
11699 ).to_ne_bytes()
11700 ),
11701});
11702}
11703unsafe extern "C" fn uniformMatrix4fv<D: DomTypes>
11704(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11705 let mut result = false;
11706 wrap_panic(&mut || result = (|| {
11707 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11708 let this = &*(this as *const D::WebGLRenderingContext);
11709 let args = &*args;
11710 let argc = args.argc_;
11711
11712 if argc < 3 {
11713 throw_type_error(cx.raw_cx(), "Not enough arguments to \"WebGLRenderingContext.uniformMatrix4fv\".");
11714 return false;
11715 }
11716 let arg0: Option<DomRoot<D::WebGLUniformLocation>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
11717 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
11718 Ok(val) => val,
11719 Err(()) => {
11720 throw_type_error(cx.raw_cx(), "value does not implement interface WebGLUniformLocation.");
11721 return false;
11722
11723 }
11724 }
11725 )
11726 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
11727 None
11728 } else {
11729 throw_type_error(cx.raw_cx(), "Value is not an object.");
11730 return false;
11731
11732 };
11733 let arg1: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
11734 Ok(ConversionResult::Success(value)) => value,
11735 Ok(ConversionResult::Failure(error)) => {
11736 throw_type_error(cx.raw_cx(), &error);
11737 return false;
11738
11739 }
11740 _ => {
11741 return false;
11742
11743 },
11744 }
11745 ;
11746 let arg2: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
11747 Ok(ConversionResult::Success(value)) => value,
11748 Ok(ConversionResult::Failure(error)) => {
11749 throw_type_error(cx.raw_cx(), &error);
11750 return false;
11751
11752 }
11753 _ => {
11754 return false;
11755
11756 },
11757 }
11758 ;
11759 let result: () = this.UniformMatrix4fv(arg0.as_deref(), arg1, arg2);
11760
11761 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11762 return true;
11763 })());
11764 result
11765}
11766
11767
11768static uniformMatrix4fv_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11769
11770pub(crate) fn init_uniformMatrix4fv_methodinfo<D: DomTypes>() {
11771 uniformMatrix4fv_methodinfo.set(JSJitInfo {
11772 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11773 method: Some(uniformMatrix4fv::<D>)
11774 },
11775 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11776 protoID: PrototypeList::ID::WebGLRenderingContext as u16,
11777 },
11778 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11779 _bitfield_align_1: [],
11780 _bitfield_1: __BindgenBitfieldUnit::new(
11781 new_jsjitinfo_bitfield_1!(
11782 JSJitInfo_OpType::Method as u8,
11783 JSJitInfo_AliasSet::AliasEverything as u8,
11784 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11785 false,
11786 false,
11787 false,
11788 false,
11789 false,
11790 false,
11791 0,
11792 ).to_ne_bytes()
11793 ),
11794});
11795}
11796unsafe extern "C" fn _finalize<D: DomTypes>
11797(_cx: *mut GCContext, obj: *mut JSObject){
11798 wrap_panic(&mut || {
11799
11800 let this = native_from_object_static::<D::WebGLRenderingContext>(obj).unwrap();
11801 finalize_weak_referenceable(obj, this);
11802 })
11803}
11804
11805unsafe extern "C" fn _trace<D: DomTypes>
11806(trc: *mut JSTracer, obj: *mut JSObject){
11807 wrap_panic(&mut || {
11808
11809 let this = native_from_object_static::<D::WebGLRenderingContext>(obj).unwrap();
11810 if this.is_null() { return; } (*this).trace(trc);
11812 })
11813}
11814
11815pub mod WebGLRenderingContextConstants {
11816 pub const DEPTH_BUFFER_BIT: u32 = 256;
11817 pub const STENCIL_BUFFER_BIT: u32 = 1024;
11818 pub const COLOR_BUFFER_BIT: u32 = 16384;
11819 pub const POINTS: u32 = 0;
11820 pub const LINES: u32 = 1;
11821 pub const LINE_LOOP: u32 = 2;
11822 pub const LINE_STRIP: u32 = 3;
11823 pub const TRIANGLES: u32 = 4;
11824 pub const TRIANGLE_STRIP: u32 = 5;
11825 pub const TRIANGLE_FAN: u32 = 6;
11826 pub const ZERO: u32 = 0;
11827 pub const ONE: u32 = 1;
11828 pub const SRC_COLOR: u32 = 768;
11829 pub const ONE_MINUS_SRC_COLOR: u32 = 769;
11830 pub const SRC_ALPHA: u32 = 770;
11831 pub const ONE_MINUS_SRC_ALPHA: u32 = 771;
11832 pub const DST_ALPHA: u32 = 772;
11833 pub const ONE_MINUS_DST_ALPHA: u32 = 773;
11834 pub const DST_COLOR: u32 = 774;
11835 pub const ONE_MINUS_DST_COLOR: u32 = 775;
11836 pub const SRC_ALPHA_SATURATE: u32 = 776;
11837 pub const FUNC_ADD: u32 = 32774;
11838 pub const BLEND_EQUATION: u32 = 32777;
11839 pub const BLEND_EQUATION_RGB: u32 = 32777;
11840 pub const BLEND_EQUATION_ALPHA: u32 = 34877;
11841 pub const FUNC_SUBTRACT: u32 = 32778;
11842 pub const FUNC_REVERSE_SUBTRACT: u32 = 32779;
11843 pub const BLEND_DST_RGB: u32 = 32968;
11844 pub const BLEND_SRC_RGB: u32 = 32969;
11845 pub const BLEND_DST_ALPHA: u32 = 32970;
11846 pub const BLEND_SRC_ALPHA: u32 = 32971;
11847 pub const CONSTANT_COLOR: u32 = 32769;
11848 pub const ONE_MINUS_CONSTANT_COLOR: u32 = 32770;
11849 pub const CONSTANT_ALPHA: u32 = 32771;
11850 pub const ONE_MINUS_CONSTANT_ALPHA: u32 = 32772;
11851 pub const BLEND_COLOR: u32 = 32773;
11852 pub const ARRAY_BUFFER: u32 = 34962;
11853 pub const ELEMENT_ARRAY_BUFFER: u32 = 34963;
11854 pub const ARRAY_BUFFER_BINDING: u32 = 34964;
11855 pub const ELEMENT_ARRAY_BUFFER_BINDING: u32 = 34965;
11856 pub const STREAM_DRAW: u32 = 35040;
11857 pub const STATIC_DRAW: u32 = 35044;
11858 pub const DYNAMIC_DRAW: u32 = 35048;
11859 pub const BUFFER_SIZE: u32 = 34660;
11860 pub const BUFFER_USAGE: u32 = 34661;
11861 pub const CURRENT_VERTEX_ATTRIB: u32 = 34342;
11862 pub const FRONT: u32 = 1028;
11863 pub const BACK: u32 = 1029;
11864 pub const FRONT_AND_BACK: u32 = 1032;
11865 pub const CULL_FACE: u32 = 2884;
11866 pub const BLEND: u32 = 3042;
11867 pub const DITHER: u32 = 3024;
11868 pub const STENCIL_TEST: u32 = 2960;
11869 pub const DEPTH_TEST: u32 = 2929;
11870 pub const SCISSOR_TEST: u32 = 3089;
11871 pub const POLYGON_OFFSET_FILL: u32 = 32823;
11872 pub const SAMPLE_ALPHA_TO_COVERAGE: u32 = 32926;
11873 pub const SAMPLE_COVERAGE: u32 = 32928;
11874 pub const NO_ERROR: u32 = 0;
11875 pub const INVALID_ENUM: u32 = 1280;
11876 pub const INVALID_VALUE: u32 = 1281;
11877 pub const INVALID_OPERATION: u32 = 1282;
11878 pub const OUT_OF_MEMORY: u32 = 1285;
11879 pub const CW: u32 = 2304;
11880 pub const CCW: u32 = 2305;
11881 pub const LINE_WIDTH: u32 = 2849;
11882 pub const ALIASED_POINT_SIZE_RANGE: u32 = 33901;
11883 pub const ALIASED_LINE_WIDTH_RANGE: u32 = 33902;
11884 pub const CULL_FACE_MODE: u32 = 2885;
11885 pub const FRONT_FACE: u32 = 2886;
11886 pub const DEPTH_RANGE: u32 = 2928;
11887 pub const DEPTH_WRITEMASK: u32 = 2930;
11888 pub const DEPTH_CLEAR_VALUE: u32 = 2931;
11889 pub const DEPTH_FUNC: u32 = 2932;
11890 pub const STENCIL_CLEAR_VALUE: u32 = 2961;
11891 pub const STENCIL_FUNC: u32 = 2962;
11892 pub const STENCIL_FAIL: u32 = 2964;
11893 pub const STENCIL_PASS_DEPTH_FAIL: u32 = 2965;
11894 pub const STENCIL_PASS_DEPTH_PASS: u32 = 2966;
11895 pub const STENCIL_REF: u32 = 2967;
11896 pub const STENCIL_VALUE_MASK: u32 = 2963;
11897 pub const STENCIL_WRITEMASK: u32 = 2968;
11898 pub const STENCIL_BACK_FUNC: u32 = 34816;
11899 pub const STENCIL_BACK_FAIL: u32 = 34817;
11900 pub const STENCIL_BACK_PASS_DEPTH_FAIL: u32 = 34818;
11901 pub const STENCIL_BACK_PASS_DEPTH_PASS: u32 = 34819;
11902 pub const STENCIL_BACK_REF: u32 = 36003;
11903 pub const STENCIL_BACK_VALUE_MASK: u32 = 36004;
11904 pub const STENCIL_BACK_WRITEMASK: u32 = 36005;
11905 pub const VIEWPORT: u32 = 2978;
11906 pub const SCISSOR_BOX: u32 = 3088;
11907 pub const COLOR_CLEAR_VALUE: u32 = 3106;
11908 pub const COLOR_WRITEMASK: u32 = 3107;
11909 pub const UNPACK_ALIGNMENT: u32 = 3317;
11910 pub const PACK_ALIGNMENT: u32 = 3333;
11911 pub const MAX_TEXTURE_SIZE: u32 = 3379;
11912 pub const MAX_VIEWPORT_DIMS: u32 = 3386;
11913 pub const SUBPIXEL_BITS: u32 = 3408;
11914 pub const RED_BITS: u32 = 3410;
11915 pub const GREEN_BITS: u32 = 3411;
11916 pub const BLUE_BITS: u32 = 3412;
11917 pub const ALPHA_BITS: u32 = 3413;
11918 pub const DEPTH_BITS: u32 = 3414;
11919 pub const STENCIL_BITS: u32 = 3415;
11920 pub const POLYGON_OFFSET_UNITS: u32 = 10752;
11921 pub const POLYGON_OFFSET_FACTOR: u32 = 32824;
11922 pub const TEXTURE_BINDING_2D: u32 = 32873;
11923 pub const SAMPLE_BUFFERS: u32 = 32936;
11924 pub const SAMPLES: u32 = 32937;
11925 pub const SAMPLE_COVERAGE_VALUE: u32 = 32938;
11926 pub const SAMPLE_COVERAGE_INVERT: u32 = 32939;
11927 pub const COMPRESSED_TEXTURE_FORMATS: u32 = 34467;
11928 pub const DONT_CARE: u32 = 4352;
11929 pub const FASTEST: u32 = 4353;
11930 pub const NICEST: u32 = 4354;
11931 pub const GENERATE_MIPMAP_HINT: u32 = 33170;
11932 pub const BYTE: u32 = 5120;
11933 pub const UNSIGNED_BYTE: u32 = 5121;
11934 pub const SHORT: u32 = 5122;
11935 pub const UNSIGNED_SHORT: u32 = 5123;
11936 pub const INT: u32 = 5124;
11937 pub const UNSIGNED_INT: u32 = 5125;
11938 pub const FLOAT: u32 = 5126;
11939 pub const DEPTH_COMPONENT: u32 = 6402;
11940 pub const ALPHA: u32 = 6406;
11941 pub const RGB: u32 = 6407;
11942 pub const RGBA: u32 = 6408;
11943 pub const LUMINANCE: u32 = 6409;
11944 pub const LUMINANCE_ALPHA: u32 = 6410;
11945 pub const UNSIGNED_SHORT_4_4_4_4: u32 = 32819;
11946 pub const UNSIGNED_SHORT_5_5_5_1: u32 = 32820;
11947 pub const UNSIGNED_SHORT_5_6_5: u32 = 33635;
11948 pub const FRAGMENT_SHADER: u32 = 35632;
11949 pub const VERTEX_SHADER: u32 = 35633;
11950 pub const MAX_VERTEX_ATTRIBS: u32 = 34921;
11951 pub const MAX_VERTEX_UNIFORM_VECTORS: u32 = 36347;
11952 pub const MAX_VARYING_VECTORS: u32 = 36348;
11953 pub const MAX_COMBINED_TEXTURE_IMAGE_UNITS: u32 = 35661;
11954 pub const MAX_VERTEX_TEXTURE_IMAGE_UNITS: u32 = 35660;
11955 pub const MAX_TEXTURE_IMAGE_UNITS: u32 = 34930;
11956 pub const MAX_FRAGMENT_UNIFORM_VECTORS: u32 = 36349;
11957 pub const SHADER_TYPE: u32 = 35663;
11958 pub const DELETE_STATUS: u32 = 35712;
11959 pub const LINK_STATUS: u32 = 35714;
11960 pub const VALIDATE_STATUS: u32 = 35715;
11961 pub const ATTACHED_SHADERS: u32 = 35717;
11962 pub const ACTIVE_UNIFORMS: u32 = 35718;
11963 pub const ACTIVE_ATTRIBUTES: u32 = 35721;
11964 pub const SHADING_LANGUAGE_VERSION: u32 = 35724;
11965 pub const CURRENT_PROGRAM: u32 = 35725;
11966 pub const NEVER: u32 = 512;
11967 pub const LESS: u32 = 513;
11968 pub const EQUAL: u32 = 514;
11969 pub const LEQUAL: u32 = 515;
11970 pub const GREATER: u32 = 516;
11971 pub const NOTEQUAL: u32 = 517;
11972 pub const GEQUAL: u32 = 518;
11973 pub const ALWAYS: u32 = 519;
11974 pub const KEEP: u32 = 7680;
11975 pub const REPLACE: u32 = 7681;
11976 pub const INCR: u32 = 7682;
11977 pub const DECR: u32 = 7683;
11978 pub const INVERT: u32 = 5386;
11979 pub const INCR_WRAP: u32 = 34055;
11980 pub const DECR_WRAP: u32 = 34056;
11981 pub const VENDOR: u32 = 7936;
11982 pub const RENDERER: u32 = 7937;
11983 pub const VERSION: u32 = 7938;
11984 pub const NEAREST: u32 = 9728;
11985 pub const LINEAR: u32 = 9729;
11986 pub const NEAREST_MIPMAP_NEAREST: u32 = 9984;
11987 pub const LINEAR_MIPMAP_NEAREST: u32 = 9985;
11988 pub const NEAREST_MIPMAP_LINEAR: u32 = 9986;
11989 pub const LINEAR_MIPMAP_LINEAR: u32 = 9987;
11990 pub const TEXTURE_MAG_FILTER: u32 = 10240;
11991 pub const TEXTURE_MIN_FILTER: u32 = 10241;
11992 pub const TEXTURE_WRAP_S: u32 = 10242;
11993 pub const TEXTURE_WRAP_T: u32 = 10243;
11994 pub const TEXTURE_2D: u32 = 3553;
11995 pub const TEXTURE: u32 = 5890;
11996 pub const TEXTURE_CUBE_MAP: u32 = 34067;
11997 pub const TEXTURE_BINDING_CUBE_MAP: u32 = 34068;
11998 pub const TEXTURE_CUBE_MAP_POSITIVE_X: u32 = 34069;
11999 pub const TEXTURE_CUBE_MAP_NEGATIVE_X: u32 = 34070;
12000 pub const TEXTURE_CUBE_MAP_POSITIVE_Y: u32 = 34071;
12001 pub const TEXTURE_CUBE_MAP_NEGATIVE_Y: u32 = 34072;
12002 pub const TEXTURE_CUBE_MAP_POSITIVE_Z: u32 = 34073;
12003 pub const TEXTURE_CUBE_MAP_NEGATIVE_Z: u32 = 34074;
12004 pub const MAX_CUBE_MAP_TEXTURE_SIZE: u32 = 34076;
12005 pub const TEXTURE0: u32 = 33984;
12006 pub const TEXTURE1: u32 = 33985;
12007 pub const TEXTURE2: u32 = 33986;
12008 pub const TEXTURE3: u32 = 33987;
12009 pub const TEXTURE4: u32 = 33988;
12010 pub const TEXTURE5: u32 = 33989;
12011 pub const TEXTURE6: u32 = 33990;
12012 pub const TEXTURE7: u32 = 33991;
12013 pub const TEXTURE8: u32 = 33992;
12014 pub const TEXTURE9: u32 = 33993;
12015 pub const TEXTURE10: u32 = 33994;
12016 pub const TEXTURE11: u32 = 33995;
12017 pub const TEXTURE12: u32 = 33996;
12018 pub const TEXTURE13: u32 = 33997;
12019 pub const TEXTURE14: u32 = 33998;
12020 pub const TEXTURE15: u32 = 33999;
12021 pub const TEXTURE16: u32 = 34000;
12022 pub const TEXTURE17: u32 = 34001;
12023 pub const TEXTURE18: u32 = 34002;
12024 pub const TEXTURE19: u32 = 34003;
12025 pub const TEXTURE20: u32 = 34004;
12026 pub const TEXTURE21: u32 = 34005;
12027 pub const TEXTURE22: u32 = 34006;
12028 pub const TEXTURE23: u32 = 34007;
12029 pub const TEXTURE24: u32 = 34008;
12030 pub const TEXTURE25: u32 = 34009;
12031 pub const TEXTURE26: u32 = 34010;
12032 pub const TEXTURE27: u32 = 34011;
12033 pub const TEXTURE28: u32 = 34012;
12034 pub const TEXTURE29: u32 = 34013;
12035 pub const TEXTURE30: u32 = 34014;
12036 pub const TEXTURE31: u32 = 34015;
12037 pub const ACTIVE_TEXTURE: u32 = 34016;
12038 pub const REPEAT: u32 = 10497;
12039 pub const CLAMP_TO_EDGE: u32 = 33071;
12040 pub const MIRRORED_REPEAT: u32 = 33648;
12041 pub const FLOAT_VEC2: u32 = 35664;
12042 pub const FLOAT_VEC3: u32 = 35665;
12043 pub const FLOAT_VEC4: u32 = 35666;
12044 pub const INT_VEC2: u32 = 35667;
12045 pub const INT_VEC3: u32 = 35668;
12046 pub const INT_VEC4: u32 = 35669;
12047 pub const BOOL: u32 = 35670;
12048 pub const BOOL_VEC2: u32 = 35671;
12049 pub const BOOL_VEC3: u32 = 35672;
12050 pub const BOOL_VEC4: u32 = 35673;
12051 pub const FLOAT_MAT2: u32 = 35674;
12052 pub const FLOAT_MAT3: u32 = 35675;
12053 pub const FLOAT_MAT4: u32 = 35676;
12054 pub const SAMPLER_2D: u32 = 35678;
12055 pub const SAMPLER_CUBE: u32 = 35680;
12056 pub const VERTEX_ATTRIB_ARRAY_ENABLED: u32 = 34338;
12057 pub const VERTEX_ATTRIB_ARRAY_SIZE: u32 = 34339;
12058 pub const VERTEX_ATTRIB_ARRAY_STRIDE: u32 = 34340;
12059 pub const VERTEX_ATTRIB_ARRAY_TYPE: u32 = 34341;
12060 pub const VERTEX_ATTRIB_ARRAY_NORMALIZED: u32 = 34922;
12061 pub const VERTEX_ATTRIB_ARRAY_POINTER: u32 = 34373;
12062 pub const VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: u32 = 34975;
12063 pub const IMPLEMENTATION_COLOR_READ_TYPE: u32 = 35738;
12064 pub const IMPLEMENTATION_COLOR_READ_FORMAT: u32 = 35739;
12065 pub const COMPILE_STATUS: u32 = 35713;
12066 pub const LOW_FLOAT: u32 = 36336;
12067 pub const MEDIUM_FLOAT: u32 = 36337;
12068 pub const HIGH_FLOAT: u32 = 36338;
12069 pub const LOW_INT: u32 = 36339;
12070 pub const MEDIUM_INT: u32 = 36340;
12071 pub const HIGH_INT: u32 = 36341;
12072 pub const FRAMEBUFFER: u32 = 36160;
12073 pub const RENDERBUFFER: u32 = 36161;
12074 pub const RGBA4: u32 = 32854;
12075 pub const RGB5_A1: u32 = 32855;
12076 pub const RGB565: u32 = 36194;
12077 pub const DEPTH_COMPONENT16: u32 = 33189;
12078 pub const STENCIL_INDEX8: u32 = 36168;
12079 pub const DEPTH_STENCIL: u32 = 34041;
12080 pub const RENDERBUFFER_WIDTH: u32 = 36162;
12081 pub const RENDERBUFFER_HEIGHT: u32 = 36163;
12082 pub const RENDERBUFFER_INTERNAL_FORMAT: u32 = 36164;
12083 pub const RENDERBUFFER_RED_SIZE: u32 = 36176;
12084 pub const RENDERBUFFER_GREEN_SIZE: u32 = 36177;
12085 pub const RENDERBUFFER_BLUE_SIZE: u32 = 36178;
12086 pub const RENDERBUFFER_ALPHA_SIZE: u32 = 36179;
12087 pub const RENDERBUFFER_DEPTH_SIZE: u32 = 36180;
12088 pub const RENDERBUFFER_STENCIL_SIZE: u32 = 36181;
12089 pub const FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: u32 = 36048;
12090 pub const FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: u32 = 36049;
12091 pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: u32 = 36050;
12092 pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: u32 = 36051;
12093 pub const COLOR_ATTACHMENT0: u32 = 36064;
12094 pub const DEPTH_ATTACHMENT: u32 = 36096;
12095 pub const STENCIL_ATTACHMENT: u32 = 36128;
12096 pub const DEPTH_STENCIL_ATTACHMENT: u32 = 33306;
12097 pub const NONE: u32 = 0;
12098 pub const FRAMEBUFFER_COMPLETE: u32 = 36053;
12099 pub const FRAMEBUFFER_INCOMPLETE_ATTACHMENT: u32 = 36054;
12100 pub const FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: u32 = 36055;
12101 pub const FRAMEBUFFER_INCOMPLETE_DIMENSIONS: u32 = 36057;
12102 pub const FRAMEBUFFER_UNSUPPORTED: u32 = 36061;
12103 pub const FRAMEBUFFER_BINDING: u32 = 36006;
12104 pub const RENDERBUFFER_BINDING: u32 = 36007;
12105 pub const MAX_RENDERBUFFER_SIZE: u32 = 34024;
12106 pub const INVALID_FRAMEBUFFER_OPERATION: u32 = 1286;
12107 pub const UNPACK_FLIP_Y_WEBGL: u32 = 37440;
12108 pub const UNPACK_PREMULTIPLY_ALPHA_WEBGL: u32 = 37441;
12109 pub const CONTEXT_LOST_WEBGL: u32 = 37442;
12110 pub const UNPACK_COLORSPACE_CONVERSION_WEBGL: u32 = 37443;
12111 pub const BROWSER_DEFAULT_WEBGL: u32 = 37444;
12112} static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();
12115
12116pub(crate) fn init_class_ops<D: DomTypes>() {
12117 CLASS_OPS.set(JSClassOps {
12118 addProperty: None,
12119 delProperty: None,
12120 enumerate: None,
12121 newEnumerate: None,
12122 resolve: None,
12123 mayResolve: None,
12124 finalize: Some(_finalize::<D>),
12125 call: None,
12126 construct: None,
12127 trace: Some(_trace::<D>),
12128 });
12129}
12130
12131pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();
12132
12133pub(crate) fn init_domjs_class<D: DomTypes>() {
12134 init_class_ops::<D>();
12135 Class.set(DOMJSClass {
12136 base: JSClass {
12137 name: c"WebGLRenderingContext".as_ptr(),
12138 flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
12139 (((2) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
12140 ,
12141 cOps: unsafe { CLASS_OPS.get() },
12142 spec: ptr::null(),
12143 ext: ptr::null(),
12144 oOps: ptr::null(),
12145 },
12146 dom_class:
12147DOMClass {
12148 interface_chain: [ PrototypeList::ID::WebGLRenderingContext, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
12149 depth: 0,
12150 type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
12151 malloc_size_of: malloc_size_of_including_raw_self::<D::WebGLRenderingContext> as unsafe fn(&mut _, _) -> _,
12152 global: Globals::EMPTY,
12153},
12154 });
12155}
12156
12157#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
12158(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::WebGLRenderingContext>, _can_gc: CanGc) -> DomRoot<D::WebGLRenderingContext>{
12159
12160 let raw = Root::new(MaybeUnreflectedDom::from_box(object));
12161
12162 let scope = scope.reflector().get_jsobject();
12163 assert!(!scope.get().is_null());
12164 assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
12165 let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());
12166
12167 rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
12168 GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
12169 assert!(!canonical_proto.is_null());
12170
12171
12172 rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
12173 if let Some(given) = given_proto {
12174 proto.set(*given);
12175 if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
12176 assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
12177 }
12178 } else {
12179 proto.set(*canonical_proto);
12180 }
12181 rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
12182 cx.raw_cx(),
12183 &Class.get().base,
12184 proto.handle(),
12185 ));
12186 assert!(!obj.is_null());
12187 JS_SetReservedSlot(
12188 obj.get(),
12189 DOM_OBJECT_SLOT,
12190 &PrivateValue(raw.as_ptr() as *const libc::c_void),
12191 );
12192
12193 let val = PrivateValue(ptr::null());
12194 JS_SetReservedSlot(obj.get(), DOM_WEAK_SLOT, &val);
12195
12196 let root = raw.reflect_with(obj.get());
12197
12198
12199
12200 DomRoot::from_ref(&*root)
12201}
12202
12203pub trait WebGLRenderingContextMethods<D: DomTypes> {
12204 fn Canvas(&self, ) -> GenericUnionTypes::HTMLCanvasElementOrOffscreenCanvas::<D>;
12205 fn DrawingBufferWidth(&self, ) -> i32;
12206 fn DrawingBufferHeight(&self, ) -> i32;
12207 fn GetContextAttributes(&self, ) -> Option<WebGLContextAttributes>;
12208 fn IsContextLost(&self, ) -> bool;
12209 fn GetSupportedExtensions(&self, ) -> Option<Vec<DOMString>>;
12210 fn GetExtension(&self, r#cx: SafeJSContext, r#name: DOMString) -> Option<NonNull<JSObject>>;
12211 fn ActiveTexture(&self, r#texture: u32);
12212 fn AttachShader(&self, r#program: &D::WebGLProgram, r#shader: &D::WebGLShader);
12213 fn BindAttribLocation(&self, r#program: &D::WebGLProgram, r#index: u32, r#name: DOMString);
12214 fn BindBuffer(&self, r#target: u32, r#buffer: Option<&D::WebGLBuffer>);
12215 fn BindFramebuffer(&self, r#target: u32, r#framebuffer: Option<&D::WebGLFramebuffer>);
12216 fn BindRenderbuffer(&self, r#target: u32, r#renderbuffer: Option<&D::WebGLRenderbuffer>);
12217 fn BindTexture(&self, r#target: u32, r#texture: Option<&D::WebGLTexture>);
12218 fn BlendColor(&self, r#red: f32, r#green: f32, r#blue: f32, r#alpha: f32);
12219 fn BlendEquation(&self, r#mode: u32);
12220 fn BlendEquationSeparate(&self, r#modeRGB: u32, r#modeAlpha: u32);
12221 fn BlendFunc(&self, r#sfactor: u32, r#dfactor: u32);
12222 fn BlendFuncSeparate(&self, r#srcRGB: u32, r#dstRGB: u32, r#srcAlpha: u32, r#dstAlpha: u32);
12223 fn CheckFramebufferStatus(&self, r#target: u32) -> u32;
12224 fn Clear(&self, r#mask: u32);
12225 fn ClearColor(&self, r#red: f32, r#green: f32, r#blue: f32, r#alpha: f32);
12226 fn ClearDepth(&self, r#depth: f32);
12227 fn ClearStencil(&self, r#s: i32);
12228 fn ColorMask(&self, r#red: bool, r#green: bool, r#blue: bool, r#alpha: bool);
12229 fn CompileShader(&self, r#shader: &D::WebGLShader);
12230 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);
12231 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);
12232 fn CreateBuffer(&self, ) -> Option<DomRoot<D::WebGLBuffer>>;
12233 fn CreateFramebuffer(&self, ) -> Option<DomRoot<D::WebGLFramebuffer>>;
12234 fn CreateProgram(&self, ) -> Option<DomRoot<D::WebGLProgram>>;
12235 fn CreateRenderbuffer(&self, ) -> Option<DomRoot<D::WebGLRenderbuffer>>;
12236 fn CreateShader(&self, r#type_: u32) -> Option<DomRoot<D::WebGLShader>>;
12237 fn CreateTexture(&self, ) -> Option<DomRoot<D::WebGLTexture>>;
12238 fn CullFace(&self, r#mode: u32);
12239 fn DeleteBuffer(&self, r#buffer: Option<&D::WebGLBuffer>);
12240 fn DeleteFramebuffer(&self, r#framebuffer: Option<&D::WebGLFramebuffer>);
12241 fn DeleteProgram(&self, r#program: Option<&D::WebGLProgram>);
12242 fn DeleteRenderbuffer(&self, r#renderbuffer: Option<&D::WebGLRenderbuffer>);
12243 fn DeleteShader(&self, r#shader: Option<&D::WebGLShader>);
12244 fn DeleteTexture(&self, r#texture: Option<&D::WebGLTexture>);
12245 fn DepthFunc(&self, r#func: u32);
12246 fn DepthMask(&self, r#flag: bool);
12247 fn DepthRange(&self, r#zNear: f32, r#zFar: f32);
12248 fn DetachShader(&self, r#program: &D::WebGLProgram, r#shader: &D::WebGLShader);
12249 fn Disable(&self, r#cap: u32);
12250 fn DisableVertexAttribArray(&self, r#index: u32);
12251 fn DrawArrays(&self, r#mode: u32, r#first: i32, r#count: i32);
12252 fn DrawElements(&self, r#mode: u32, r#count: i32, r#type_: u32, r#offset: i64);
12253 fn Enable(&self, r#cap: u32);
12254 fn EnableVertexAttribArray(&self, r#index: u32);
12255 fn Finish(&self, );
12256 fn Flush(&self, );
12257 fn FramebufferRenderbuffer(&self, r#target: u32, r#attachment: u32, r#renderbuffertarget: u32, r#renderbuffer: Option<&D::WebGLRenderbuffer>);
12258 fn FramebufferTexture2D(&self, r#target: u32, r#attachment: u32, r#textarget: u32, r#texture: Option<&D::WebGLTexture>, r#level: i32);
12259 fn FrontFace(&self, r#mode: u32);
12260 fn GenerateMipmap(&self, r#target: u32);
12261 fn GetActiveAttrib(&self, r#program: &D::WebGLProgram, r#index: u32) -> Option<DomRoot<D::WebGLActiveInfo>>;
12262 fn GetActiveUniform(&self, r#program: &D::WebGLProgram, r#index: u32) -> Option<DomRoot<D::WebGLActiveInfo>>;
12263 fn GetAttachedShaders(&self, r#program: &D::WebGLProgram) -> Option<Vec<DomRoot<D::WebGLShader>>>;
12264 fn GetAttribLocation(&self, r#program: &D::WebGLProgram, r#name: DOMString) -> i32;
12265 fn GetBufferParameter(&self, r#cx: SafeJSContext, r#target: u32, r#pname: u32, r#rval: MutableHandleValue);
12266 fn GetParameter(&self, r#cx: SafeJSContext, r#pname: u32, r#rval: MutableHandleValue);
12267 fn GetError(&self, ) -> u32;
12268 fn GetFramebufferAttachmentParameter(&self, r#cx: SafeJSContext, r#target: u32, r#attachment: u32, r#pname: u32, r#rval: MutableHandleValue);
12269 fn GetProgramParameter(&self, r#cx: SafeJSContext, r#program: &D::WebGLProgram, r#pname: u32, r#rval: MutableHandleValue);
12270 fn GetProgramInfoLog(&self, r#program: &D::WebGLProgram) -> Option<DOMString>;
12271 fn GetRenderbufferParameter(&self, r#cx: SafeJSContext, r#target: u32, r#pname: u32, r#rval: MutableHandleValue);
12272 fn GetShaderParameter(&self, r#cx: SafeJSContext, r#shader: &D::WebGLShader, r#pname: u32, r#rval: MutableHandleValue);
12273 fn GetShaderPrecisionFormat(&self, r#shadertype: u32, r#precisiontype: u32) -> Option<DomRoot<D::WebGLShaderPrecisionFormat>>;
12274 fn GetShaderInfoLog(&self, r#shader: &D::WebGLShader) -> Option<DOMString>;
12275 fn GetShaderSource(&self, r#shader: &D::WebGLShader) -> Option<DOMString>;
12276 fn GetTexParameter(&self, r#cx: SafeJSContext, r#target: u32, r#pname: u32, r#rval: MutableHandleValue);
12277 fn GetUniform(&self, r#cx: SafeJSContext, r#program: &D::WebGLProgram, r#location: &D::WebGLUniformLocation, r#rval: MutableHandleValue);
12278 fn GetUniformLocation(&self, r#program: &D::WebGLProgram, r#name: DOMString) -> Option<DomRoot<D::WebGLUniformLocation>>;
12279 fn GetVertexAttrib(&self, r#cx: SafeJSContext, r#index: u32, r#pname: u32, r#rval: MutableHandleValue);
12280 fn GetVertexAttribOffset(&self, r#index: u32, r#pname: u32) -> i64;
12281 fn Hint(&self, r#target: u32, r#mode: u32);
12282 fn IsBuffer(&self, r#buffer: Option<&D::WebGLBuffer>) -> bool;
12283 fn IsEnabled(&self, r#cap: u32) -> bool;
12284 fn IsFramebuffer(&self, r#framebuffer: Option<&D::WebGLFramebuffer>) -> bool;
12285 fn IsProgram(&self, r#program: Option<&D::WebGLProgram>) -> bool;
12286 fn IsRenderbuffer(&self, r#renderbuffer: Option<&D::WebGLRenderbuffer>) -> bool;
12287 fn IsShader(&self, r#shader: Option<&D::WebGLShader>) -> bool;
12288 fn IsTexture(&self, r#texture: Option<&D::WebGLTexture>) -> bool;
12289 fn LineWidth(&self, r#width: f32);
12290 fn LinkProgram(&self, r#program: &D::WebGLProgram);
12291 fn PixelStorei(&self, r#pname: u32, r#param: i32);
12292 fn PolygonOffset(&self, r#factor: f32, r#units: f32);
12293 fn RenderbufferStorage(&self, r#target: u32, r#internalformat: u32, r#width: i32, r#height: i32);
12294 fn SampleCoverage(&self, r#value: f32, r#invert: bool);
12295 fn Scissor(&self, r#x: i32, r#y: i32, r#width: i32, r#height: i32);
12296 fn ShaderSource(&self, r#shader: &D::WebGLShader, r#source: DOMString);
12297 fn StencilFunc(&self, r#func: u32, r#ref_: i32, r#mask: u32);
12298 fn StencilFuncSeparate(&self, r#face: u32, r#func: u32, r#ref_: i32, r#mask: u32);
12299 fn StencilMask(&self, r#mask: u32);
12300 fn StencilMaskSeparate(&self, r#face: u32, r#mask: u32);
12301 fn StencilOp(&self, r#fail: u32, r#zfail: u32, r#zpass: u32);
12302 fn StencilOpSeparate(&self, r#face: u32, r#fail: u32, r#zfail: u32, r#zpass: u32);
12303 fn TexParameterf(&self, r#target: u32, r#pname: u32, r#param: f32);
12304 fn TexParameteri(&self, r#target: u32, r#pname: u32, r#param: i32);
12305 fn Uniform1f(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: f32);
12306 fn Uniform2f(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: f32, r#y: f32);
12307 fn Uniform3f(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: f32, r#y: f32, r#z: f32);
12308 fn Uniform4f(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: f32, r#y: f32, r#z: f32, r#w: f32);
12309 fn Uniform1i(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: i32);
12310 fn Uniform2i(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: i32, r#y: i32);
12311 fn Uniform3i(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: i32, r#y: i32, r#z: i32);
12312 fn Uniform4i(&self, r#location: Option<&D::WebGLUniformLocation>, r#x: i32, r#y: i32, r#z: i32, r#w: i32);
12313 fn UseProgram(&self, r#program: Option<&D::WebGLProgram>);
12314 fn ValidateProgram(&self, r#program: &D::WebGLProgram);
12315 fn VertexAttrib1f(&self, r#indx: u32, r#x: f32);
12316 fn VertexAttrib2f(&self, r#indx: u32, r#x: f32, r#y: f32);
12317 fn VertexAttrib3f(&self, r#indx: u32, r#x: f32, r#y: f32, r#z: f32);
12318 fn VertexAttrib4f(&self, r#indx: u32, r#x: f32, r#y: f32, r#z: f32, r#w: f32);
12319 fn VertexAttrib1fv(&self, r#indx: u32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12320 fn VertexAttrib2fv(&self, r#indx: u32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12321 fn VertexAttrib3fv(&self, r#indx: u32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12322 fn VertexAttrib4fv(&self, r#indx: u32, r#values: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12323 fn VertexAttribPointer(&self, r#indx: u32, r#size: i32, r#type_: u32, r#normalized: bool, r#stride: i32, r#offset: i64);
12324 fn Viewport(&self, r#x: i32, r#y: i32, r#width: i32, r#height: i32);
12325 fn MakeXRCompatible(&self, r#_can_gc: CanGc) -> Rc<D::Promise>;
12326 fn BufferData(&self, r#target: u32, r#size: i64, r#usage: u32);
12327 fn BufferData_(&self, r#target: u32, r#data: Option<GenericUnionTypes::ArrayBufferViewOrArrayBuffer >, r#usage: u32);
12328 fn BufferSubData(&self, r#target: u32, r#offset: i64, r#data: GenericUnionTypes::ArrayBufferViewOrArrayBuffer);
12329 fn CompressedTexImage2D(&self, r#target: u32, r#level: i32, r#internalformat: u32, r#width: i32, r#height: i32, r#border: i32, r#data: CustomAutoRooterGuard<typedarray::ArrayBufferView>);
12330 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#data: CustomAutoRooterGuard<typedarray::ArrayBufferView>);
12331 fn ReadPixels(&self, r#x: i32, r#y: i32, r#width: i32, r#height: i32, r#format: u32, r#type_: u32, r#pixels: CustomAutoRooterGuard<Option<typedarray::ArrayBufferView>>);
12332 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<()>;
12333 fn TexImage2D_(&self, r#target: u32, r#level: i32, r#internalformat: i32, r#format: u32, r#type_: u32, r#source: GenericUnionTypes::ImageBitmapOrImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::<D>) -> Fallible<()>;
12334 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<()>;
12335 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<()>;
12336 fn Uniform1fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#v: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12337 fn Uniform2fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#v: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12338 fn Uniform3fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#v: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12339 fn Uniform4fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#v: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12340 fn Uniform1iv(&self, r#location: Option<&D::WebGLUniformLocation>, r#v: GenericUnionTypes::Int32ArrayOrLongSequence);
12341 fn Uniform2iv(&self, r#location: Option<&D::WebGLUniformLocation>, r#v: GenericUnionTypes::Int32ArrayOrLongSequence);
12342 fn Uniform3iv(&self, r#location: Option<&D::WebGLUniformLocation>, r#v: GenericUnionTypes::Int32ArrayOrLongSequence);
12343 fn Uniform4iv(&self, r#location: Option<&D::WebGLUniformLocation>, r#v: GenericUnionTypes::Int32ArrayOrLongSequence);
12344 fn UniformMatrix2fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#value: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12345 fn UniformMatrix3fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#value: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12346 fn UniformMatrix4fv(&self, r#location: Option<&D::WebGLUniformLocation>, r#transpose: bool, r#value: GenericUnionTypes::Float32ArrayOrUnrestrictedFloatSequence);
12347}
12348static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
12349
12350pub(crate) fn init_sMethods_specs<D: DomTypes>() {
12351 sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
12352 JSFunctionSpec {
12353 name: JSPropertySpec_Name { string_: c"getContextAttributes".as_ptr() },
12354 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getContextAttributes_methodinfo.get() } as *const _ as *const JSJitInfo },
12355 nargs: 0,
12356 flags: (JSPROP_ENUMERATE) as u16,
12357 selfHostedName: ptr::null()
12358 },
12359 JSFunctionSpec {
12360 name: JSPropertySpec_Name { string_: c"isContextLost".as_ptr() },
12361 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isContextLost_methodinfo.get() } as *const _ as *const JSJitInfo },
12362 nargs: 0,
12363 flags: (JSPROP_ENUMERATE) as u16,
12364 selfHostedName: ptr::null()
12365 },
12366 JSFunctionSpec {
12367 name: JSPropertySpec_Name { string_: c"getSupportedExtensions".as_ptr() },
12368 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getSupportedExtensions_methodinfo.get() } as *const _ as *const JSJitInfo },
12369 nargs: 0,
12370 flags: (JSPROP_ENUMERATE) as u16,
12371 selfHostedName: ptr::null()
12372 },
12373 JSFunctionSpec {
12374 name: JSPropertySpec_Name { string_: c"getExtension".as_ptr() },
12375 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getExtension_methodinfo.get() } as *const _ as *const JSJitInfo },
12376 nargs: 1,
12377 flags: (JSPROP_ENUMERATE) as u16,
12378 selfHostedName: ptr::null()
12379 },
12380 JSFunctionSpec {
12381 name: JSPropertySpec_Name { string_: c"activeTexture".as_ptr() },
12382 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { activeTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
12383 nargs: 1,
12384 flags: (JSPROP_ENUMERATE) as u16,
12385 selfHostedName: ptr::null()
12386 },
12387 JSFunctionSpec {
12388 name: JSPropertySpec_Name { string_: c"attachShader".as_ptr() },
12389 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { attachShader_methodinfo.get() } as *const _ as *const JSJitInfo },
12390 nargs: 2,
12391 flags: (JSPROP_ENUMERATE) as u16,
12392 selfHostedName: ptr::null()
12393 },
12394 JSFunctionSpec {
12395 name: JSPropertySpec_Name { string_: c"bindAttribLocation".as_ptr() },
12396 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindAttribLocation_methodinfo.get() } as *const _ as *const JSJitInfo },
12397 nargs: 3,
12398 flags: (JSPROP_ENUMERATE) as u16,
12399 selfHostedName: ptr::null()
12400 },
12401 JSFunctionSpec {
12402 name: JSPropertySpec_Name { string_: c"bindBuffer".as_ptr() },
12403 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12404 nargs: 2,
12405 flags: (JSPROP_ENUMERATE) as u16,
12406 selfHostedName: ptr::null()
12407 },
12408 JSFunctionSpec {
12409 name: JSPropertySpec_Name { string_: c"bindFramebuffer".as_ptr() },
12410 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12411 nargs: 2,
12412 flags: (JSPROP_ENUMERATE) as u16,
12413 selfHostedName: ptr::null()
12414 },
12415 JSFunctionSpec {
12416 name: JSPropertySpec_Name { string_: c"bindRenderbuffer".as_ptr() },
12417 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12418 nargs: 2,
12419 flags: (JSPROP_ENUMERATE) as u16,
12420 selfHostedName: ptr::null()
12421 },
12422 JSFunctionSpec {
12423 name: JSPropertySpec_Name { string_: c"bindTexture".as_ptr() },
12424 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bindTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
12425 nargs: 2,
12426 flags: (JSPROP_ENUMERATE) as u16,
12427 selfHostedName: ptr::null()
12428 },
12429 JSFunctionSpec {
12430 name: JSPropertySpec_Name { string_: c"blendColor".as_ptr() },
12431 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendColor_methodinfo.get() } as *const _ as *const JSJitInfo },
12432 nargs: 4,
12433 flags: (JSPROP_ENUMERATE) as u16,
12434 selfHostedName: ptr::null()
12435 },
12436 JSFunctionSpec {
12437 name: JSPropertySpec_Name { string_: c"blendEquation".as_ptr() },
12438 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendEquation_methodinfo.get() } as *const _ as *const JSJitInfo },
12439 nargs: 1,
12440 flags: (JSPROP_ENUMERATE) as u16,
12441 selfHostedName: ptr::null()
12442 },
12443 JSFunctionSpec {
12444 name: JSPropertySpec_Name { string_: c"blendEquationSeparate".as_ptr() },
12445 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendEquationSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
12446 nargs: 2,
12447 flags: (JSPROP_ENUMERATE) as u16,
12448 selfHostedName: ptr::null()
12449 },
12450 JSFunctionSpec {
12451 name: JSPropertySpec_Name { string_: c"blendFunc".as_ptr() },
12452 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendFunc_methodinfo.get() } as *const _ as *const JSJitInfo },
12453 nargs: 2,
12454 flags: (JSPROP_ENUMERATE) as u16,
12455 selfHostedName: ptr::null()
12456 },
12457 JSFunctionSpec {
12458 name: JSPropertySpec_Name { string_: c"blendFuncSeparate".as_ptr() },
12459 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { blendFuncSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
12460 nargs: 4,
12461 flags: (JSPROP_ENUMERATE) as u16,
12462 selfHostedName: ptr::null()
12463 },
12464 JSFunctionSpec {
12465 name: JSPropertySpec_Name { string_: c"checkFramebufferStatus".as_ptr() },
12466 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { checkFramebufferStatus_methodinfo.get() } as *const _ as *const JSJitInfo },
12467 nargs: 1,
12468 flags: (JSPROP_ENUMERATE) as u16,
12469 selfHostedName: ptr::null()
12470 },
12471 JSFunctionSpec {
12472 name: JSPropertySpec_Name { string_: c"clear".as_ptr() },
12473 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clear_methodinfo.get() } as *const _ as *const JSJitInfo },
12474 nargs: 1,
12475 flags: (JSPROP_ENUMERATE) as u16,
12476 selfHostedName: ptr::null()
12477 },
12478 JSFunctionSpec {
12479 name: JSPropertySpec_Name { string_: c"clearColor".as_ptr() },
12480 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearColor_methodinfo.get() } as *const _ as *const JSJitInfo },
12481 nargs: 4,
12482 flags: (JSPROP_ENUMERATE) as u16,
12483 selfHostedName: ptr::null()
12484 },
12485 JSFunctionSpec {
12486 name: JSPropertySpec_Name { string_: c"clearDepth".as_ptr() },
12487 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearDepth_methodinfo.get() } as *const _ as *const JSJitInfo },
12488 nargs: 1,
12489 flags: (JSPROP_ENUMERATE) as u16,
12490 selfHostedName: ptr::null()
12491 },
12492 JSFunctionSpec {
12493 name: JSPropertySpec_Name { string_: c"clearStencil".as_ptr() },
12494 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { clearStencil_methodinfo.get() } as *const _ as *const JSJitInfo },
12495 nargs: 1,
12496 flags: (JSPROP_ENUMERATE) as u16,
12497 selfHostedName: ptr::null()
12498 },
12499 JSFunctionSpec {
12500 name: JSPropertySpec_Name { string_: c"colorMask".as_ptr() },
12501 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { colorMask_methodinfo.get() } as *const _ as *const JSJitInfo },
12502 nargs: 4,
12503 flags: (JSPROP_ENUMERATE) as u16,
12504 selfHostedName: ptr::null()
12505 },
12506 JSFunctionSpec {
12507 name: JSPropertySpec_Name { string_: c"compileShader".as_ptr() },
12508 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { compileShader_methodinfo.get() } as *const _ as *const JSJitInfo },
12509 nargs: 1,
12510 flags: (JSPROP_ENUMERATE) as u16,
12511 selfHostedName: ptr::null()
12512 },
12513 JSFunctionSpec {
12514 name: JSPropertySpec_Name { string_: c"copyTexImage2D".as_ptr() },
12515 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyTexImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
12516 nargs: 8,
12517 flags: (JSPROP_ENUMERATE) as u16,
12518 selfHostedName: ptr::null()
12519 },
12520 JSFunctionSpec {
12521 name: JSPropertySpec_Name { string_: c"copyTexSubImage2D".as_ptr() },
12522 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyTexSubImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
12523 nargs: 8,
12524 flags: (JSPROP_ENUMERATE) as u16,
12525 selfHostedName: ptr::null()
12526 },
12527 JSFunctionSpec {
12528 name: JSPropertySpec_Name { string_: c"createBuffer".as_ptr() },
12529 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12530 nargs: 0,
12531 flags: (JSPROP_ENUMERATE) as u16,
12532 selfHostedName: ptr::null()
12533 },
12534 JSFunctionSpec {
12535 name: JSPropertySpec_Name { string_: c"createFramebuffer".as_ptr() },
12536 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12537 nargs: 0,
12538 flags: (JSPROP_ENUMERATE) as u16,
12539 selfHostedName: ptr::null()
12540 },
12541 JSFunctionSpec {
12542 name: JSPropertySpec_Name { string_: c"createProgram".as_ptr() },
12543 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
12544 nargs: 0,
12545 flags: (JSPROP_ENUMERATE) as u16,
12546 selfHostedName: ptr::null()
12547 },
12548 JSFunctionSpec {
12549 name: JSPropertySpec_Name { string_: c"createRenderbuffer".as_ptr() },
12550 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12551 nargs: 0,
12552 flags: (JSPROP_ENUMERATE) as u16,
12553 selfHostedName: ptr::null()
12554 },
12555 JSFunctionSpec {
12556 name: JSPropertySpec_Name { string_: c"createShader".as_ptr() },
12557 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createShader_methodinfo.get() } as *const _ as *const JSJitInfo },
12558 nargs: 1,
12559 flags: (JSPROP_ENUMERATE) as u16,
12560 selfHostedName: ptr::null()
12561 },
12562 JSFunctionSpec {
12563 name: JSPropertySpec_Name { string_: c"createTexture".as_ptr() },
12564 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
12565 nargs: 0,
12566 flags: (JSPROP_ENUMERATE) as u16,
12567 selfHostedName: ptr::null()
12568 },
12569 JSFunctionSpec {
12570 name: JSPropertySpec_Name { string_: c"cullFace".as_ptr() },
12571 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { cullFace_methodinfo.get() } as *const _ as *const JSJitInfo },
12572 nargs: 1,
12573 flags: (JSPROP_ENUMERATE) as u16,
12574 selfHostedName: ptr::null()
12575 },
12576 JSFunctionSpec {
12577 name: JSPropertySpec_Name { string_: c"deleteBuffer".as_ptr() },
12578 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12579 nargs: 1,
12580 flags: (JSPROP_ENUMERATE) as u16,
12581 selfHostedName: ptr::null()
12582 },
12583 JSFunctionSpec {
12584 name: JSPropertySpec_Name { string_: c"deleteFramebuffer".as_ptr() },
12585 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12586 nargs: 1,
12587 flags: (JSPROP_ENUMERATE) as u16,
12588 selfHostedName: ptr::null()
12589 },
12590 JSFunctionSpec {
12591 name: JSPropertySpec_Name { string_: c"deleteProgram".as_ptr() },
12592 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
12593 nargs: 1,
12594 flags: (JSPROP_ENUMERATE) as u16,
12595 selfHostedName: ptr::null()
12596 },
12597 JSFunctionSpec {
12598 name: JSPropertySpec_Name { string_: c"deleteRenderbuffer".as_ptr() },
12599 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12600 nargs: 1,
12601 flags: (JSPROP_ENUMERATE) as u16,
12602 selfHostedName: ptr::null()
12603 },
12604 JSFunctionSpec {
12605 name: JSPropertySpec_Name { string_: c"deleteShader".as_ptr() },
12606 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteShader_methodinfo.get() } as *const _ as *const JSJitInfo },
12607 nargs: 1,
12608 flags: (JSPROP_ENUMERATE) as u16,
12609 selfHostedName: ptr::null()
12610 },
12611 JSFunctionSpec {
12612 name: JSPropertySpec_Name { string_: c"deleteTexture".as_ptr() },
12613 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { deleteTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
12614 nargs: 1,
12615 flags: (JSPROP_ENUMERATE) as u16,
12616 selfHostedName: ptr::null()
12617 },
12618 JSFunctionSpec {
12619 name: JSPropertySpec_Name { string_: c"depthFunc".as_ptr() },
12620 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { depthFunc_methodinfo.get() } as *const _ as *const JSJitInfo },
12621 nargs: 1,
12622 flags: (JSPROP_ENUMERATE) as u16,
12623 selfHostedName: ptr::null()
12624 },
12625 JSFunctionSpec {
12626 name: JSPropertySpec_Name { string_: c"depthMask".as_ptr() },
12627 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { depthMask_methodinfo.get() } as *const _ as *const JSJitInfo },
12628 nargs: 1,
12629 flags: (JSPROP_ENUMERATE) as u16,
12630 selfHostedName: ptr::null()
12631 },
12632 JSFunctionSpec {
12633 name: JSPropertySpec_Name { string_: c"depthRange".as_ptr() },
12634 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { depthRange_methodinfo.get() } as *const _ as *const JSJitInfo },
12635 nargs: 2,
12636 flags: (JSPROP_ENUMERATE) as u16,
12637 selfHostedName: ptr::null()
12638 },
12639 JSFunctionSpec {
12640 name: JSPropertySpec_Name { string_: c"detachShader".as_ptr() },
12641 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { detachShader_methodinfo.get() } as *const _ as *const JSJitInfo },
12642 nargs: 2,
12643 flags: (JSPROP_ENUMERATE) as u16,
12644 selfHostedName: ptr::null()
12645 },
12646 JSFunctionSpec {
12647 name: JSPropertySpec_Name { string_: c"disable".as_ptr() },
12648 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { disable_methodinfo.get() } as *const _ as *const JSJitInfo },
12649 nargs: 1,
12650 flags: (JSPROP_ENUMERATE) as u16,
12651 selfHostedName: ptr::null()
12652 },
12653 JSFunctionSpec {
12654 name: JSPropertySpec_Name { string_: c"disableVertexAttribArray".as_ptr() },
12655 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { disableVertexAttribArray_methodinfo.get() } as *const _ as *const JSJitInfo },
12656 nargs: 1,
12657 flags: (JSPROP_ENUMERATE) as u16,
12658 selfHostedName: ptr::null()
12659 },
12660 JSFunctionSpec {
12661 name: JSPropertySpec_Name { string_: c"drawArrays".as_ptr() },
12662 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawArrays_methodinfo.get() } as *const _ as *const JSJitInfo },
12663 nargs: 3,
12664 flags: (JSPROP_ENUMERATE) as u16,
12665 selfHostedName: ptr::null()
12666 },
12667 JSFunctionSpec {
12668 name: JSPropertySpec_Name { string_: c"drawElements".as_ptr() },
12669 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawElements_methodinfo.get() } as *const _ as *const JSJitInfo },
12670 nargs: 4,
12671 flags: (JSPROP_ENUMERATE) as u16,
12672 selfHostedName: ptr::null()
12673 },
12674 JSFunctionSpec {
12675 name: JSPropertySpec_Name { string_: c"enable".as_ptr() },
12676 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { enable_methodinfo.get() } as *const _ as *const JSJitInfo },
12677 nargs: 1,
12678 flags: (JSPROP_ENUMERATE) as u16,
12679 selfHostedName: ptr::null()
12680 },
12681 JSFunctionSpec {
12682 name: JSPropertySpec_Name { string_: c"enableVertexAttribArray".as_ptr() },
12683 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { enableVertexAttribArray_methodinfo.get() } as *const _ as *const JSJitInfo },
12684 nargs: 1,
12685 flags: (JSPROP_ENUMERATE) as u16,
12686 selfHostedName: ptr::null()
12687 },
12688 JSFunctionSpec {
12689 name: JSPropertySpec_Name { string_: c"finish".as_ptr() },
12690 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { finish_methodinfo.get() } as *const _ as *const JSJitInfo },
12691 nargs: 0,
12692 flags: (JSPROP_ENUMERATE) as u16,
12693 selfHostedName: ptr::null()
12694 },
12695 JSFunctionSpec {
12696 name: JSPropertySpec_Name { string_: c"flush".as_ptr() },
12697 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { flush_methodinfo.get() } as *const _ as *const JSJitInfo },
12698 nargs: 0,
12699 flags: (JSPROP_ENUMERATE) as u16,
12700 selfHostedName: ptr::null()
12701 },
12702 JSFunctionSpec {
12703 name: JSPropertySpec_Name { string_: c"framebufferRenderbuffer".as_ptr() },
12704 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { framebufferRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12705 nargs: 4,
12706 flags: (JSPROP_ENUMERATE) as u16,
12707 selfHostedName: ptr::null()
12708 },
12709 JSFunctionSpec {
12710 name: JSPropertySpec_Name { string_: c"framebufferTexture2D".as_ptr() },
12711 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { framebufferTexture2D_methodinfo.get() } as *const _ as *const JSJitInfo },
12712 nargs: 5,
12713 flags: (JSPROP_ENUMERATE) as u16,
12714 selfHostedName: ptr::null()
12715 },
12716 JSFunctionSpec {
12717 name: JSPropertySpec_Name { string_: c"frontFace".as_ptr() },
12718 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { frontFace_methodinfo.get() } as *const _ as *const JSJitInfo },
12719 nargs: 1,
12720 flags: (JSPROP_ENUMERATE) as u16,
12721 selfHostedName: ptr::null()
12722 },
12723 JSFunctionSpec {
12724 name: JSPropertySpec_Name { string_: c"generateMipmap".as_ptr() },
12725 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { generateMipmap_methodinfo.get() } as *const _ as *const JSJitInfo },
12726 nargs: 1,
12727 flags: (JSPROP_ENUMERATE) as u16,
12728 selfHostedName: ptr::null()
12729 },
12730 JSFunctionSpec {
12731 name: JSPropertySpec_Name { string_: c"getActiveAttrib".as_ptr() },
12732 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getActiveAttrib_methodinfo.get() } as *const _ as *const JSJitInfo },
12733 nargs: 2,
12734 flags: (JSPROP_ENUMERATE) as u16,
12735 selfHostedName: ptr::null()
12736 },
12737 JSFunctionSpec {
12738 name: JSPropertySpec_Name { string_: c"getActiveUniform".as_ptr() },
12739 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getActiveUniform_methodinfo.get() } as *const _ as *const JSJitInfo },
12740 nargs: 2,
12741 flags: (JSPROP_ENUMERATE) as u16,
12742 selfHostedName: ptr::null()
12743 },
12744 JSFunctionSpec {
12745 name: JSPropertySpec_Name { string_: c"getAttachedShaders".as_ptr() },
12746 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getAttachedShaders_methodinfo.get() } as *const _ as *const JSJitInfo },
12747 nargs: 1,
12748 flags: (JSPROP_ENUMERATE) as u16,
12749 selfHostedName: ptr::null()
12750 },
12751 JSFunctionSpec {
12752 name: JSPropertySpec_Name { string_: c"getAttribLocation".as_ptr() },
12753 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getAttribLocation_methodinfo.get() } as *const _ as *const JSJitInfo },
12754 nargs: 2,
12755 flags: (JSPROP_ENUMERATE) as u16,
12756 selfHostedName: ptr::null()
12757 },
12758 JSFunctionSpec {
12759 name: JSPropertySpec_Name { string_: c"getBufferParameter".as_ptr() },
12760 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getBufferParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
12761 nargs: 2,
12762 flags: (JSPROP_ENUMERATE) as u16,
12763 selfHostedName: ptr::null()
12764 },
12765 JSFunctionSpec {
12766 name: JSPropertySpec_Name { string_: c"getParameter".as_ptr() },
12767 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
12768 nargs: 1,
12769 flags: (JSPROP_ENUMERATE) as u16,
12770 selfHostedName: ptr::null()
12771 },
12772 JSFunctionSpec {
12773 name: JSPropertySpec_Name { string_: c"getError".as_ptr() },
12774 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getError_methodinfo.get() } as *const _ as *const JSJitInfo },
12775 nargs: 0,
12776 flags: (JSPROP_ENUMERATE) as u16,
12777 selfHostedName: ptr::null()
12778 },
12779 JSFunctionSpec {
12780 name: JSPropertySpec_Name { string_: c"getFramebufferAttachmentParameter".as_ptr() },
12781 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getFramebufferAttachmentParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
12782 nargs: 3,
12783 flags: (JSPROP_ENUMERATE) as u16,
12784 selfHostedName: ptr::null()
12785 },
12786 JSFunctionSpec {
12787 name: JSPropertySpec_Name { string_: c"getProgramParameter".as_ptr() },
12788 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getProgramParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
12789 nargs: 2,
12790 flags: (JSPROP_ENUMERATE) as u16,
12791 selfHostedName: ptr::null()
12792 },
12793 JSFunctionSpec {
12794 name: JSPropertySpec_Name { string_: c"getProgramInfoLog".as_ptr() },
12795 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getProgramInfoLog_methodinfo.get() } as *const _ as *const JSJitInfo },
12796 nargs: 1,
12797 flags: (JSPROP_ENUMERATE) as u16,
12798 selfHostedName: ptr::null()
12799 },
12800 JSFunctionSpec {
12801 name: JSPropertySpec_Name { string_: c"getRenderbufferParameter".as_ptr() },
12802 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getRenderbufferParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
12803 nargs: 2,
12804 flags: (JSPROP_ENUMERATE) as u16,
12805 selfHostedName: ptr::null()
12806 },
12807 JSFunctionSpec {
12808 name: JSPropertySpec_Name { string_: c"getShaderParameter".as_ptr() },
12809 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getShaderParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
12810 nargs: 2,
12811 flags: (JSPROP_ENUMERATE) as u16,
12812 selfHostedName: ptr::null()
12813 },
12814 JSFunctionSpec {
12815 name: JSPropertySpec_Name { string_: c"getShaderPrecisionFormat".as_ptr() },
12816 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getShaderPrecisionFormat_methodinfo.get() } as *const _ as *const JSJitInfo },
12817 nargs: 2,
12818 flags: (JSPROP_ENUMERATE) as u16,
12819 selfHostedName: ptr::null()
12820 },
12821 JSFunctionSpec {
12822 name: JSPropertySpec_Name { string_: c"getShaderInfoLog".as_ptr() },
12823 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getShaderInfoLog_methodinfo.get() } as *const _ as *const JSJitInfo },
12824 nargs: 1,
12825 flags: (JSPROP_ENUMERATE) as u16,
12826 selfHostedName: ptr::null()
12827 },
12828 JSFunctionSpec {
12829 name: JSPropertySpec_Name { string_: c"getShaderSource".as_ptr() },
12830 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getShaderSource_methodinfo.get() } as *const _ as *const JSJitInfo },
12831 nargs: 1,
12832 flags: (JSPROP_ENUMERATE) as u16,
12833 selfHostedName: ptr::null()
12834 },
12835 JSFunctionSpec {
12836 name: JSPropertySpec_Name { string_: c"getTexParameter".as_ptr() },
12837 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getTexParameter_methodinfo.get() } as *const _ as *const JSJitInfo },
12838 nargs: 2,
12839 flags: (JSPROP_ENUMERATE) as u16,
12840 selfHostedName: ptr::null()
12841 },
12842 JSFunctionSpec {
12843 name: JSPropertySpec_Name { string_: c"getUniform".as_ptr() },
12844 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getUniform_methodinfo.get() } as *const _ as *const JSJitInfo },
12845 nargs: 2,
12846 flags: (JSPROP_ENUMERATE) as u16,
12847 selfHostedName: ptr::null()
12848 },
12849 JSFunctionSpec {
12850 name: JSPropertySpec_Name { string_: c"getUniformLocation".as_ptr() },
12851 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getUniformLocation_methodinfo.get() } as *const _ as *const JSJitInfo },
12852 nargs: 2,
12853 flags: (JSPROP_ENUMERATE) as u16,
12854 selfHostedName: ptr::null()
12855 },
12856 JSFunctionSpec {
12857 name: JSPropertySpec_Name { string_: c"getVertexAttrib".as_ptr() },
12858 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getVertexAttrib_methodinfo.get() } as *const _ as *const JSJitInfo },
12859 nargs: 2,
12860 flags: (JSPROP_ENUMERATE) as u16,
12861 selfHostedName: ptr::null()
12862 },
12863 JSFunctionSpec {
12864 name: JSPropertySpec_Name { string_: c"getVertexAttribOffset".as_ptr() },
12865 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getVertexAttribOffset_methodinfo.get() } as *const _ as *const JSJitInfo },
12866 nargs: 2,
12867 flags: (JSPROP_ENUMERATE) as u16,
12868 selfHostedName: ptr::null()
12869 },
12870 JSFunctionSpec {
12871 name: JSPropertySpec_Name { string_: c"hint".as_ptr() },
12872 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { hint_methodinfo.get() } as *const _ as *const JSJitInfo },
12873 nargs: 2,
12874 flags: (JSPROP_ENUMERATE) as u16,
12875 selfHostedName: ptr::null()
12876 },
12877 JSFunctionSpec {
12878 name: JSPropertySpec_Name { string_: c"isBuffer".as_ptr() },
12879 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12880 nargs: 1,
12881 flags: (JSPROP_ENUMERATE) as u16,
12882 selfHostedName: ptr::null()
12883 },
12884 JSFunctionSpec {
12885 name: JSPropertySpec_Name { string_: c"isEnabled".as_ptr() },
12886 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isEnabled_methodinfo.get() } as *const _ as *const JSJitInfo },
12887 nargs: 1,
12888 flags: (JSPROP_ENUMERATE) as u16,
12889 selfHostedName: ptr::null()
12890 },
12891 JSFunctionSpec {
12892 name: JSPropertySpec_Name { string_: c"isFramebuffer".as_ptr() },
12893 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isFramebuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12894 nargs: 1,
12895 flags: (JSPROP_ENUMERATE) as u16,
12896 selfHostedName: ptr::null()
12897 },
12898 JSFunctionSpec {
12899 name: JSPropertySpec_Name { string_: c"isProgram".as_ptr() },
12900 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
12901 nargs: 1,
12902 flags: (JSPROP_ENUMERATE) as u16,
12903 selfHostedName: ptr::null()
12904 },
12905 JSFunctionSpec {
12906 name: JSPropertySpec_Name { string_: c"isRenderbuffer".as_ptr() },
12907 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isRenderbuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
12908 nargs: 1,
12909 flags: (JSPROP_ENUMERATE) as u16,
12910 selfHostedName: ptr::null()
12911 },
12912 JSFunctionSpec {
12913 name: JSPropertySpec_Name { string_: c"isShader".as_ptr() },
12914 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isShader_methodinfo.get() } as *const _ as *const JSJitInfo },
12915 nargs: 1,
12916 flags: (JSPROP_ENUMERATE) as u16,
12917 selfHostedName: ptr::null()
12918 },
12919 JSFunctionSpec {
12920 name: JSPropertySpec_Name { string_: c"isTexture".as_ptr() },
12921 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { isTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
12922 nargs: 1,
12923 flags: (JSPROP_ENUMERATE) as u16,
12924 selfHostedName: ptr::null()
12925 },
12926 JSFunctionSpec {
12927 name: JSPropertySpec_Name { string_: c"lineWidth".as_ptr() },
12928 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { lineWidth_methodinfo.get() } as *const _ as *const JSJitInfo },
12929 nargs: 1,
12930 flags: (JSPROP_ENUMERATE) as u16,
12931 selfHostedName: ptr::null()
12932 },
12933 JSFunctionSpec {
12934 name: JSPropertySpec_Name { string_: c"linkProgram".as_ptr() },
12935 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { linkProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
12936 nargs: 1,
12937 flags: (JSPROP_ENUMERATE) as u16,
12938 selfHostedName: ptr::null()
12939 },
12940 JSFunctionSpec {
12941 name: JSPropertySpec_Name { string_: c"pixelStorei".as_ptr() },
12942 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { pixelStorei_methodinfo.get() } as *const _ as *const JSJitInfo },
12943 nargs: 2,
12944 flags: (JSPROP_ENUMERATE) as u16,
12945 selfHostedName: ptr::null()
12946 },
12947 JSFunctionSpec {
12948 name: JSPropertySpec_Name { string_: c"polygonOffset".as_ptr() },
12949 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { polygonOffset_methodinfo.get() } as *const _ as *const JSJitInfo },
12950 nargs: 2,
12951 flags: (JSPROP_ENUMERATE) as u16,
12952 selfHostedName: ptr::null()
12953 },
12954 JSFunctionSpec {
12955 name: JSPropertySpec_Name { string_: c"renderbufferStorage".as_ptr() },
12956 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { renderbufferStorage_methodinfo.get() } as *const _ as *const JSJitInfo },
12957 nargs: 4,
12958 flags: (JSPROP_ENUMERATE) as u16,
12959 selfHostedName: ptr::null()
12960 },
12961 JSFunctionSpec {
12962 name: JSPropertySpec_Name { string_: c"sampleCoverage".as_ptr() },
12963 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { sampleCoverage_methodinfo.get() } as *const _ as *const JSJitInfo },
12964 nargs: 2,
12965 flags: (JSPROP_ENUMERATE) as u16,
12966 selfHostedName: ptr::null()
12967 },
12968 JSFunctionSpec {
12969 name: JSPropertySpec_Name { string_: c"scissor".as_ptr() },
12970 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { scissor_methodinfo.get() } as *const _ as *const JSJitInfo },
12971 nargs: 4,
12972 flags: (JSPROP_ENUMERATE) as u16,
12973 selfHostedName: ptr::null()
12974 },
12975 JSFunctionSpec {
12976 name: JSPropertySpec_Name { string_: c"shaderSource".as_ptr() },
12977 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { shaderSource_methodinfo.get() } as *const _ as *const JSJitInfo },
12978 nargs: 2,
12979 flags: (JSPROP_ENUMERATE) as u16,
12980 selfHostedName: ptr::null()
12981 },
12982 JSFunctionSpec {
12983 name: JSPropertySpec_Name { string_: c"stencilFunc".as_ptr() },
12984 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilFunc_methodinfo.get() } as *const _ as *const JSJitInfo },
12985 nargs: 3,
12986 flags: (JSPROP_ENUMERATE) as u16,
12987 selfHostedName: ptr::null()
12988 },
12989 JSFunctionSpec {
12990 name: JSPropertySpec_Name { string_: c"stencilFuncSeparate".as_ptr() },
12991 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilFuncSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
12992 nargs: 4,
12993 flags: (JSPROP_ENUMERATE) as u16,
12994 selfHostedName: ptr::null()
12995 },
12996 JSFunctionSpec {
12997 name: JSPropertySpec_Name { string_: c"stencilMask".as_ptr() },
12998 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilMask_methodinfo.get() } as *const _ as *const JSJitInfo },
12999 nargs: 1,
13000 flags: (JSPROP_ENUMERATE) as u16,
13001 selfHostedName: ptr::null()
13002 },
13003 JSFunctionSpec {
13004 name: JSPropertySpec_Name { string_: c"stencilMaskSeparate".as_ptr() },
13005 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilMaskSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
13006 nargs: 2,
13007 flags: (JSPROP_ENUMERATE) as u16,
13008 selfHostedName: ptr::null()
13009 },
13010 JSFunctionSpec {
13011 name: JSPropertySpec_Name { string_: c"stencilOp".as_ptr() },
13012 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilOp_methodinfo.get() } as *const _ as *const JSJitInfo },
13013 nargs: 3,
13014 flags: (JSPROP_ENUMERATE) as u16,
13015 selfHostedName: ptr::null()
13016 },
13017 JSFunctionSpec {
13018 name: JSPropertySpec_Name { string_: c"stencilOpSeparate".as_ptr() },
13019 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stencilOpSeparate_methodinfo.get() } as *const _ as *const JSJitInfo },
13020 nargs: 4,
13021 flags: (JSPROP_ENUMERATE) as u16,
13022 selfHostedName: ptr::null()
13023 },
13024 JSFunctionSpec {
13025 name: JSPropertySpec_Name { string_: c"texParameterf".as_ptr() },
13026 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texParameterf_methodinfo.get() } as *const _ as *const JSJitInfo },
13027 nargs: 3,
13028 flags: (JSPROP_ENUMERATE) as u16,
13029 selfHostedName: ptr::null()
13030 },
13031 JSFunctionSpec {
13032 name: JSPropertySpec_Name { string_: c"texParameteri".as_ptr() },
13033 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texParameteri_methodinfo.get() } as *const _ as *const JSJitInfo },
13034 nargs: 3,
13035 flags: (JSPROP_ENUMERATE) as u16,
13036 selfHostedName: ptr::null()
13037 },
13038 JSFunctionSpec {
13039 name: JSPropertySpec_Name { string_: c"uniform1f".as_ptr() },
13040 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1f_methodinfo.get() } as *const _ as *const JSJitInfo },
13041 nargs: 2,
13042 flags: (JSPROP_ENUMERATE) as u16,
13043 selfHostedName: ptr::null()
13044 },
13045 JSFunctionSpec {
13046 name: JSPropertySpec_Name { string_: c"uniform2f".as_ptr() },
13047 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2f_methodinfo.get() } as *const _ as *const JSJitInfo },
13048 nargs: 3,
13049 flags: (JSPROP_ENUMERATE) as u16,
13050 selfHostedName: ptr::null()
13051 },
13052 JSFunctionSpec {
13053 name: JSPropertySpec_Name { string_: c"uniform3f".as_ptr() },
13054 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3f_methodinfo.get() } as *const _ as *const JSJitInfo },
13055 nargs: 4,
13056 flags: (JSPROP_ENUMERATE) as u16,
13057 selfHostedName: ptr::null()
13058 },
13059 JSFunctionSpec {
13060 name: JSPropertySpec_Name { string_: c"uniform4f".as_ptr() },
13061 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4f_methodinfo.get() } as *const _ as *const JSJitInfo },
13062 nargs: 5,
13063 flags: (JSPROP_ENUMERATE) as u16,
13064 selfHostedName: ptr::null()
13065 },
13066 JSFunctionSpec {
13067 name: JSPropertySpec_Name { string_: c"uniform1i".as_ptr() },
13068 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1i_methodinfo.get() } as *const _ as *const JSJitInfo },
13069 nargs: 2,
13070 flags: (JSPROP_ENUMERATE) as u16,
13071 selfHostedName: ptr::null()
13072 },
13073 JSFunctionSpec {
13074 name: JSPropertySpec_Name { string_: c"uniform2i".as_ptr() },
13075 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2i_methodinfo.get() } as *const _ as *const JSJitInfo },
13076 nargs: 3,
13077 flags: (JSPROP_ENUMERATE) as u16,
13078 selfHostedName: ptr::null()
13079 },
13080 JSFunctionSpec {
13081 name: JSPropertySpec_Name { string_: c"uniform3i".as_ptr() },
13082 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3i_methodinfo.get() } as *const _ as *const JSJitInfo },
13083 nargs: 4,
13084 flags: (JSPROP_ENUMERATE) as u16,
13085 selfHostedName: ptr::null()
13086 },
13087 JSFunctionSpec {
13088 name: JSPropertySpec_Name { string_: c"uniform4i".as_ptr() },
13089 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4i_methodinfo.get() } as *const _ as *const JSJitInfo },
13090 nargs: 5,
13091 flags: (JSPROP_ENUMERATE) as u16,
13092 selfHostedName: ptr::null()
13093 },
13094 JSFunctionSpec {
13095 name: JSPropertySpec_Name { string_: c"useProgram".as_ptr() },
13096 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { useProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
13097 nargs: 1,
13098 flags: (JSPROP_ENUMERATE) as u16,
13099 selfHostedName: ptr::null()
13100 },
13101 JSFunctionSpec {
13102 name: JSPropertySpec_Name { string_: c"validateProgram".as_ptr() },
13103 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { validateProgram_methodinfo.get() } as *const _ as *const JSJitInfo },
13104 nargs: 1,
13105 flags: (JSPROP_ENUMERATE) as u16,
13106 selfHostedName: ptr::null()
13107 },
13108 JSFunctionSpec {
13109 name: JSPropertySpec_Name { string_: c"vertexAttrib1f".as_ptr() },
13110 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib1f_methodinfo.get() } as *const _ as *const JSJitInfo },
13111 nargs: 2,
13112 flags: (JSPROP_ENUMERATE) as u16,
13113 selfHostedName: ptr::null()
13114 },
13115 JSFunctionSpec {
13116 name: JSPropertySpec_Name { string_: c"vertexAttrib2f".as_ptr() },
13117 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib2f_methodinfo.get() } as *const _ as *const JSJitInfo },
13118 nargs: 3,
13119 flags: (JSPROP_ENUMERATE) as u16,
13120 selfHostedName: ptr::null()
13121 },
13122 JSFunctionSpec {
13123 name: JSPropertySpec_Name { string_: c"vertexAttrib3f".as_ptr() },
13124 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib3f_methodinfo.get() } as *const _ as *const JSJitInfo },
13125 nargs: 4,
13126 flags: (JSPROP_ENUMERATE) as u16,
13127 selfHostedName: ptr::null()
13128 },
13129 JSFunctionSpec {
13130 name: JSPropertySpec_Name { string_: c"vertexAttrib4f".as_ptr() },
13131 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib4f_methodinfo.get() } as *const _ as *const JSJitInfo },
13132 nargs: 5,
13133 flags: (JSPROP_ENUMERATE) as u16,
13134 selfHostedName: ptr::null()
13135 },
13136 JSFunctionSpec {
13137 name: JSPropertySpec_Name { string_: c"vertexAttrib1fv".as_ptr() },
13138 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib1fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13139 nargs: 2,
13140 flags: (JSPROP_ENUMERATE) as u16,
13141 selfHostedName: ptr::null()
13142 },
13143 JSFunctionSpec {
13144 name: JSPropertySpec_Name { string_: c"vertexAttrib2fv".as_ptr() },
13145 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib2fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13146 nargs: 2,
13147 flags: (JSPROP_ENUMERATE) as u16,
13148 selfHostedName: ptr::null()
13149 },
13150 JSFunctionSpec {
13151 name: JSPropertySpec_Name { string_: c"vertexAttrib3fv".as_ptr() },
13152 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib3fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13153 nargs: 2,
13154 flags: (JSPROP_ENUMERATE) as u16,
13155 selfHostedName: ptr::null()
13156 },
13157 JSFunctionSpec {
13158 name: JSPropertySpec_Name { string_: c"vertexAttrib4fv".as_ptr() },
13159 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttrib4fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13160 nargs: 2,
13161 flags: (JSPROP_ENUMERATE) as u16,
13162 selfHostedName: ptr::null()
13163 },
13164 JSFunctionSpec {
13165 name: JSPropertySpec_Name { string_: c"vertexAttribPointer".as_ptr() },
13166 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { vertexAttribPointer_methodinfo.get() } as *const _ as *const JSJitInfo },
13167 nargs: 6,
13168 flags: (JSPROP_ENUMERATE) as u16,
13169 selfHostedName: ptr::null()
13170 },
13171 JSFunctionSpec {
13172 name: JSPropertySpec_Name { string_: c"viewport".as_ptr() },
13173 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { viewport_methodinfo.get() } as *const _ as *const JSJitInfo },
13174 nargs: 4,
13175 flags: (JSPROP_ENUMERATE) as u16,
13176 selfHostedName: ptr::null()
13177 },
13178 JSFunctionSpec {
13179 name: JSPropertySpec_Name { string_: ptr::null() },
13180 call: JSNativeWrapper { op: None, info: ptr::null() },
13181 nargs: 0,
13182 flags: 0,
13183 selfHostedName: ptr::null()
13184 }]))[..]
13185,
13186&Box::leak(Box::new([
13187 JSFunctionSpec {
13188 name: JSPropertySpec_Name { string_: c"makeXRCompatible".as_ptr() },
13189 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { makeXRCompatible_methodinfo.get() } as *const _ as *const JSJitInfo },
13190 nargs: 0,
13191 flags: (JSPROP_ENUMERATE) as u16,
13192 selfHostedName: ptr::null()
13193 },
13194 JSFunctionSpec {
13195 name: JSPropertySpec_Name { string_: ptr::null() },
13196 call: JSNativeWrapper { op: None, info: ptr::null() },
13197 nargs: 0,
13198 flags: 0,
13199 selfHostedName: ptr::null()
13200 }]))[..]
13201,
13202&Box::leak(Box::new([
13203 JSFunctionSpec {
13204 name: JSPropertySpec_Name { string_: c"bufferData".as_ptr() },
13205 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bufferData_methodinfo.get() } as *const _ as *const JSJitInfo },
13206 nargs: 3,
13207 flags: (JSPROP_ENUMERATE) as u16,
13208 selfHostedName: ptr::null()
13209 },
13210 JSFunctionSpec {
13211 name: JSPropertySpec_Name { string_: c"bufferSubData".as_ptr() },
13212 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { bufferSubData_methodinfo.get() } as *const _ as *const JSJitInfo },
13213 nargs: 3,
13214 flags: (JSPROP_ENUMERATE) as u16,
13215 selfHostedName: ptr::null()
13216 },
13217 JSFunctionSpec {
13218 name: JSPropertySpec_Name { string_: c"compressedTexImage2D".as_ptr() },
13219 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { compressedTexImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
13220 nargs: 7,
13221 flags: (JSPROP_ENUMERATE) as u16,
13222 selfHostedName: ptr::null()
13223 },
13224 JSFunctionSpec {
13225 name: JSPropertySpec_Name { string_: c"compressedTexSubImage2D".as_ptr() },
13226 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { compressedTexSubImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
13227 nargs: 8,
13228 flags: (JSPROP_ENUMERATE) as u16,
13229 selfHostedName: ptr::null()
13230 },
13231 JSFunctionSpec {
13232 name: JSPropertySpec_Name { string_: c"readPixels".as_ptr() },
13233 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { readPixels_methodinfo.get() } as *const _ as *const JSJitInfo },
13234 nargs: 7,
13235 flags: (JSPROP_ENUMERATE) as u16,
13236 selfHostedName: ptr::null()
13237 },
13238 JSFunctionSpec {
13239 name: JSPropertySpec_Name { string_: c"texImage2D".as_ptr() },
13240 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
13241 nargs: 6,
13242 flags: (JSPROP_ENUMERATE) as u16,
13243 selfHostedName: ptr::null()
13244 },
13245 JSFunctionSpec {
13246 name: JSPropertySpec_Name { string_: c"texSubImage2D".as_ptr() },
13247 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { texSubImage2D_methodinfo.get() } as *const _ as *const JSJitInfo },
13248 nargs: 7,
13249 flags: (JSPROP_ENUMERATE) as u16,
13250 selfHostedName: ptr::null()
13251 },
13252 JSFunctionSpec {
13253 name: JSPropertySpec_Name { string_: c"uniform1fv".as_ptr() },
13254 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13255 nargs: 2,
13256 flags: (JSPROP_ENUMERATE) as u16,
13257 selfHostedName: ptr::null()
13258 },
13259 JSFunctionSpec {
13260 name: JSPropertySpec_Name { string_: c"uniform2fv".as_ptr() },
13261 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13262 nargs: 2,
13263 flags: (JSPROP_ENUMERATE) as u16,
13264 selfHostedName: ptr::null()
13265 },
13266 JSFunctionSpec {
13267 name: JSPropertySpec_Name { string_: c"uniform3fv".as_ptr() },
13268 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13269 nargs: 2,
13270 flags: (JSPROP_ENUMERATE) as u16,
13271 selfHostedName: ptr::null()
13272 },
13273 JSFunctionSpec {
13274 name: JSPropertySpec_Name { string_: c"uniform4fv".as_ptr() },
13275 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13276 nargs: 2,
13277 flags: (JSPROP_ENUMERATE) as u16,
13278 selfHostedName: ptr::null()
13279 },
13280 JSFunctionSpec {
13281 name: JSPropertySpec_Name { string_: c"uniform1iv".as_ptr() },
13282 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform1iv_methodinfo.get() } as *const _ as *const JSJitInfo },
13283 nargs: 2,
13284 flags: (JSPROP_ENUMERATE) as u16,
13285 selfHostedName: ptr::null()
13286 },
13287 JSFunctionSpec {
13288 name: JSPropertySpec_Name { string_: c"uniform2iv".as_ptr() },
13289 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform2iv_methodinfo.get() } as *const _ as *const JSJitInfo },
13290 nargs: 2,
13291 flags: (JSPROP_ENUMERATE) as u16,
13292 selfHostedName: ptr::null()
13293 },
13294 JSFunctionSpec {
13295 name: JSPropertySpec_Name { string_: c"uniform3iv".as_ptr() },
13296 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform3iv_methodinfo.get() } as *const _ as *const JSJitInfo },
13297 nargs: 2,
13298 flags: (JSPROP_ENUMERATE) as u16,
13299 selfHostedName: ptr::null()
13300 },
13301 JSFunctionSpec {
13302 name: JSPropertySpec_Name { string_: c"uniform4iv".as_ptr() },
13303 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniform4iv_methodinfo.get() } as *const _ as *const JSJitInfo },
13304 nargs: 2,
13305 flags: (JSPROP_ENUMERATE) as u16,
13306 selfHostedName: ptr::null()
13307 },
13308 JSFunctionSpec {
13309 name: JSPropertySpec_Name { string_: c"uniformMatrix2fv".as_ptr() },
13310 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix2fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13311 nargs: 3,
13312 flags: (JSPROP_ENUMERATE) as u16,
13313 selfHostedName: ptr::null()
13314 },
13315 JSFunctionSpec {
13316 name: JSPropertySpec_Name { string_: c"uniformMatrix3fv".as_ptr() },
13317 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix3fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13318 nargs: 3,
13319 flags: (JSPROP_ENUMERATE) as u16,
13320 selfHostedName: ptr::null()
13321 },
13322 JSFunctionSpec {
13323 name: JSPropertySpec_Name { string_: c"uniformMatrix4fv".as_ptr() },
13324 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { uniformMatrix4fv_methodinfo.get() } as *const _ as *const JSJitInfo },
13325 nargs: 3,
13326 flags: (JSPROP_ENUMERATE) as u16,
13327 selfHostedName: ptr::null()
13328 },
13329 JSFunctionSpec {
13330 name: JSPropertySpec_Name { string_: ptr::null() },
13331 call: JSNativeWrapper { op: None, info: ptr::null() },
13332 nargs: 0,
13333 flags: 0,
13334 selfHostedName: ptr::null()
13335 }]))[..]
13336])));
13337}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
13338
13339pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
13340 sMethods.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 { sMethods_specs.get() })[0]),
13341 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() })[1]),
13342 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[2])])));
13343}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
13344
13345pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
13346 sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
13347 JSPropertySpec {
13348 name: JSPropertySpec_Name { string_: c"canvas".as_ptr() },
13349 attributes_: (JSPROP_ENUMERATE),
13350 kind_: (JSPropertySpec_Kind::NativeAccessor),
13351 u: JSPropertySpec_AccessorsOrValue {
13352 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
13353 getter: JSPropertySpec_Accessor {
13354 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { canvas_getterinfo.get() } },
13355 },
13356 setter: JSPropertySpec_Accessor {
13357 native: JSNativeWrapper { op: None, info: ptr::null() },
13358 }
13359 }
13360 }
13361 }
13362,
13363 JSPropertySpec {
13364 name: JSPropertySpec_Name { string_: c"drawingBufferWidth".as_ptr() },
13365 attributes_: (JSPROP_ENUMERATE),
13366 kind_: (JSPropertySpec_Kind::NativeAccessor),
13367 u: JSPropertySpec_AccessorsOrValue {
13368 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
13369 getter: JSPropertySpec_Accessor {
13370 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { drawingBufferWidth_getterinfo.get() } },
13371 },
13372 setter: JSPropertySpec_Accessor {
13373 native: JSNativeWrapper { op: None, info: ptr::null() },
13374 }
13375 }
13376 }
13377 }
13378,
13379 JSPropertySpec {
13380 name: JSPropertySpec_Name { string_: c"drawingBufferHeight".as_ptr() },
13381 attributes_: (JSPROP_ENUMERATE),
13382 kind_: (JSPropertySpec_Kind::NativeAccessor),
13383 u: JSPropertySpec_AccessorsOrValue {
13384 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
13385 getter: JSPropertySpec_Accessor {
13386 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { drawingBufferHeight_getterinfo.get() } },
13387 },
13388 setter: JSPropertySpec_Accessor {
13389 native: JSNativeWrapper { op: None, info: ptr::null() },
13390 }
13391 }
13392 }
13393 }
13394,
13395 JSPropertySpec::ZERO]))[..]
13396,
13397&Box::leak(Box::new([
13398 JSPropertySpec {
13399 name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
13400 attributes_: (JSPROP_READONLY),
13401 kind_: (JSPropertySpec_Kind::Value),
13402 u: JSPropertySpec_AccessorsOrValue {
13403 value: JSPropertySpec_ValueWrapper {
13404 type_: JSPropertySpec_ValueWrapper_Type::String,
13405 __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
13406 string: c"WebGLRenderingContext".as_ptr(),
13407 }
13408 }
13409 }
13410 }
13411,
13412 JSPropertySpec::ZERO]))[..]
13413])));
13414}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
13415
13416pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
13417 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]),
13418 Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
13419}static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();
13420
13421pub(crate) fn init_sConstants_specs<D: DomTypes>() {
13422 sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
13423 ConstantSpec { name: c"DEPTH_BUFFER_BIT", value: ConstantVal::Uint(256) },
13424 ConstantSpec { name: c"STENCIL_BUFFER_BIT", value: ConstantVal::Uint(1024) },
13425 ConstantSpec { name: c"COLOR_BUFFER_BIT", value: ConstantVal::Uint(16384) },
13426 ConstantSpec { name: c"POINTS", value: ConstantVal::Uint(0) },
13427 ConstantSpec { name: c"LINES", value: ConstantVal::Uint(1) },
13428 ConstantSpec { name: c"LINE_LOOP", value: ConstantVal::Uint(2) },
13429 ConstantSpec { name: c"LINE_STRIP", value: ConstantVal::Uint(3) },
13430 ConstantSpec { name: c"TRIANGLES", value: ConstantVal::Uint(4) },
13431 ConstantSpec { name: c"TRIANGLE_STRIP", value: ConstantVal::Uint(5) },
13432 ConstantSpec { name: c"TRIANGLE_FAN", value: ConstantVal::Uint(6) },
13433 ConstantSpec { name: c"ZERO", value: ConstantVal::Uint(0) },
13434 ConstantSpec { name: c"ONE", value: ConstantVal::Uint(1) },
13435 ConstantSpec { name: c"SRC_COLOR", value: ConstantVal::Uint(768) },
13436 ConstantSpec { name: c"ONE_MINUS_SRC_COLOR", value: ConstantVal::Uint(769) },
13437 ConstantSpec { name: c"SRC_ALPHA", value: ConstantVal::Uint(770) },
13438 ConstantSpec { name: c"ONE_MINUS_SRC_ALPHA", value: ConstantVal::Uint(771) },
13439 ConstantSpec { name: c"DST_ALPHA", value: ConstantVal::Uint(772) },
13440 ConstantSpec { name: c"ONE_MINUS_DST_ALPHA", value: ConstantVal::Uint(773) },
13441 ConstantSpec { name: c"DST_COLOR", value: ConstantVal::Uint(774) },
13442 ConstantSpec { name: c"ONE_MINUS_DST_COLOR", value: ConstantVal::Uint(775) },
13443 ConstantSpec { name: c"SRC_ALPHA_SATURATE", value: ConstantVal::Uint(776) },
13444 ConstantSpec { name: c"FUNC_ADD", value: ConstantVal::Uint(32774) },
13445 ConstantSpec { name: c"BLEND_EQUATION", value: ConstantVal::Uint(32777) },
13446 ConstantSpec { name: c"BLEND_EQUATION_RGB", value: ConstantVal::Uint(32777) },
13447 ConstantSpec { name: c"BLEND_EQUATION_ALPHA", value: ConstantVal::Uint(34877) },
13448 ConstantSpec { name: c"FUNC_SUBTRACT", value: ConstantVal::Uint(32778) },
13449 ConstantSpec { name: c"FUNC_REVERSE_SUBTRACT", value: ConstantVal::Uint(32779) },
13450 ConstantSpec { name: c"BLEND_DST_RGB", value: ConstantVal::Uint(32968) },
13451 ConstantSpec { name: c"BLEND_SRC_RGB", value: ConstantVal::Uint(32969) },
13452 ConstantSpec { name: c"BLEND_DST_ALPHA", value: ConstantVal::Uint(32970) },
13453 ConstantSpec { name: c"BLEND_SRC_ALPHA", value: ConstantVal::Uint(32971) },
13454 ConstantSpec { name: c"CONSTANT_COLOR", value: ConstantVal::Uint(32769) },
13455 ConstantSpec { name: c"ONE_MINUS_CONSTANT_COLOR", value: ConstantVal::Uint(32770) },
13456 ConstantSpec { name: c"CONSTANT_ALPHA", value: ConstantVal::Uint(32771) },
13457 ConstantSpec { name: c"ONE_MINUS_CONSTANT_ALPHA", value: ConstantVal::Uint(32772) },
13458 ConstantSpec { name: c"BLEND_COLOR", value: ConstantVal::Uint(32773) },
13459 ConstantSpec { name: c"ARRAY_BUFFER", value: ConstantVal::Uint(34962) },
13460 ConstantSpec { name: c"ELEMENT_ARRAY_BUFFER", value: ConstantVal::Uint(34963) },
13461 ConstantSpec { name: c"ARRAY_BUFFER_BINDING", value: ConstantVal::Uint(34964) },
13462 ConstantSpec { name: c"ELEMENT_ARRAY_BUFFER_BINDING", value: ConstantVal::Uint(34965) },
13463 ConstantSpec { name: c"STREAM_DRAW", value: ConstantVal::Uint(35040) },
13464 ConstantSpec { name: c"STATIC_DRAW", value: ConstantVal::Uint(35044) },
13465 ConstantSpec { name: c"DYNAMIC_DRAW", value: ConstantVal::Uint(35048) },
13466 ConstantSpec { name: c"BUFFER_SIZE", value: ConstantVal::Uint(34660) },
13467 ConstantSpec { name: c"BUFFER_USAGE", value: ConstantVal::Uint(34661) },
13468 ConstantSpec { name: c"CURRENT_VERTEX_ATTRIB", value: ConstantVal::Uint(34342) },
13469 ConstantSpec { name: c"FRONT", value: ConstantVal::Uint(1028) },
13470 ConstantSpec { name: c"BACK", value: ConstantVal::Uint(1029) },
13471 ConstantSpec { name: c"FRONT_AND_BACK", value: ConstantVal::Uint(1032) },
13472 ConstantSpec { name: c"CULL_FACE", value: ConstantVal::Uint(2884) },
13473 ConstantSpec { name: c"BLEND", value: ConstantVal::Uint(3042) },
13474 ConstantSpec { name: c"DITHER", value: ConstantVal::Uint(3024) },
13475 ConstantSpec { name: c"STENCIL_TEST", value: ConstantVal::Uint(2960) },
13476 ConstantSpec { name: c"DEPTH_TEST", value: ConstantVal::Uint(2929) },
13477 ConstantSpec { name: c"SCISSOR_TEST", value: ConstantVal::Uint(3089) },
13478 ConstantSpec { name: c"POLYGON_OFFSET_FILL", value: ConstantVal::Uint(32823) },
13479 ConstantSpec { name: c"SAMPLE_ALPHA_TO_COVERAGE", value: ConstantVal::Uint(32926) },
13480 ConstantSpec { name: c"SAMPLE_COVERAGE", value: ConstantVal::Uint(32928) },
13481 ConstantSpec { name: c"NO_ERROR", value: ConstantVal::Uint(0) },
13482 ConstantSpec { name: c"INVALID_ENUM", value: ConstantVal::Uint(1280) },
13483 ConstantSpec { name: c"INVALID_VALUE", value: ConstantVal::Uint(1281) },
13484 ConstantSpec { name: c"INVALID_OPERATION", value: ConstantVal::Uint(1282) },
13485 ConstantSpec { name: c"OUT_OF_MEMORY", value: ConstantVal::Uint(1285) },
13486 ConstantSpec { name: c"CW", value: ConstantVal::Uint(2304) },
13487 ConstantSpec { name: c"CCW", value: ConstantVal::Uint(2305) },
13488 ConstantSpec { name: c"LINE_WIDTH", value: ConstantVal::Uint(2849) },
13489 ConstantSpec { name: c"ALIASED_POINT_SIZE_RANGE", value: ConstantVal::Uint(33901) },
13490 ConstantSpec { name: c"ALIASED_LINE_WIDTH_RANGE", value: ConstantVal::Uint(33902) },
13491 ConstantSpec { name: c"CULL_FACE_MODE", value: ConstantVal::Uint(2885) },
13492 ConstantSpec { name: c"FRONT_FACE", value: ConstantVal::Uint(2886) },
13493 ConstantSpec { name: c"DEPTH_RANGE", value: ConstantVal::Uint(2928) },
13494 ConstantSpec { name: c"DEPTH_WRITEMASK", value: ConstantVal::Uint(2930) },
13495 ConstantSpec { name: c"DEPTH_CLEAR_VALUE", value: ConstantVal::Uint(2931) },
13496 ConstantSpec { name: c"DEPTH_FUNC", value: ConstantVal::Uint(2932) },
13497 ConstantSpec { name: c"STENCIL_CLEAR_VALUE", value: ConstantVal::Uint(2961) },
13498 ConstantSpec { name: c"STENCIL_FUNC", value: ConstantVal::Uint(2962) },
13499 ConstantSpec { name: c"STENCIL_FAIL", value: ConstantVal::Uint(2964) },
13500 ConstantSpec { name: c"STENCIL_PASS_DEPTH_FAIL", value: ConstantVal::Uint(2965) },
13501 ConstantSpec { name: c"STENCIL_PASS_DEPTH_PASS", value: ConstantVal::Uint(2966) },
13502 ConstantSpec { name: c"STENCIL_REF", value: ConstantVal::Uint(2967) },
13503 ConstantSpec { name: c"STENCIL_VALUE_MASK", value: ConstantVal::Uint(2963) },
13504 ConstantSpec { name: c"STENCIL_WRITEMASK", value: ConstantVal::Uint(2968) },
13505 ConstantSpec { name: c"STENCIL_BACK_FUNC", value: ConstantVal::Uint(34816) },
13506 ConstantSpec { name: c"STENCIL_BACK_FAIL", value: ConstantVal::Uint(34817) },
13507 ConstantSpec { name: c"STENCIL_BACK_PASS_DEPTH_FAIL", value: ConstantVal::Uint(34818) },
13508 ConstantSpec { name: c"STENCIL_BACK_PASS_DEPTH_PASS", value: ConstantVal::Uint(34819) },
13509 ConstantSpec { name: c"STENCIL_BACK_REF", value: ConstantVal::Uint(36003) },
13510 ConstantSpec { name: c"STENCIL_BACK_VALUE_MASK", value: ConstantVal::Uint(36004) },
13511 ConstantSpec { name: c"STENCIL_BACK_WRITEMASK", value: ConstantVal::Uint(36005) },
13512 ConstantSpec { name: c"VIEWPORT", value: ConstantVal::Uint(2978) },
13513 ConstantSpec { name: c"SCISSOR_BOX", value: ConstantVal::Uint(3088) },
13514 ConstantSpec { name: c"COLOR_CLEAR_VALUE", value: ConstantVal::Uint(3106) },
13515 ConstantSpec { name: c"COLOR_WRITEMASK", value: ConstantVal::Uint(3107) },
13516 ConstantSpec { name: c"UNPACK_ALIGNMENT", value: ConstantVal::Uint(3317) },
13517 ConstantSpec { name: c"PACK_ALIGNMENT", value: ConstantVal::Uint(3333) },
13518 ConstantSpec { name: c"MAX_TEXTURE_SIZE", value: ConstantVal::Uint(3379) },
13519 ConstantSpec { name: c"MAX_VIEWPORT_DIMS", value: ConstantVal::Uint(3386) },
13520 ConstantSpec { name: c"SUBPIXEL_BITS", value: ConstantVal::Uint(3408) },
13521 ConstantSpec { name: c"RED_BITS", value: ConstantVal::Uint(3410) },
13522 ConstantSpec { name: c"GREEN_BITS", value: ConstantVal::Uint(3411) },
13523 ConstantSpec { name: c"BLUE_BITS", value: ConstantVal::Uint(3412) },
13524 ConstantSpec { name: c"ALPHA_BITS", value: ConstantVal::Uint(3413) },
13525 ConstantSpec { name: c"DEPTH_BITS", value: ConstantVal::Uint(3414) },
13526 ConstantSpec { name: c"STENCIL_BITS", value: ConstantVal::Uint(3415) },
13527 ConstantSpec { name: c"POLYGON_OFFSET_UNITS", value: ConstantVal::Uint(10752) },
13528 ConstantSpec { name: c"POLYGON_OFFSET_FACTOR", value: ConstantVal::Uint(32824) },
13529 ConstantSpec { name: c"TEXTURE_BINDING_2D", value: ConstantVal::Uint(32873) },
13530 ConstantSpec { name: c"SAMPLE_BUFFERS", value: ConstantVal::Uint(32936) },
13531 ConstantSpec { name: c"SAMPLES", value: ConstantVal::Uint(32937) },
13532 ConstantSpec { name: c"SAMPLE_COVERAGE_VALUE", value: ConstantVal::Uint(32938) },
13533 ConstantSpec { name: c"SAMPLE_COVERAGE_INVERT", value: ConstantVal::Uint(32939) },
13534 ConstantSpec { name: c"COMPRESSED_TEXTURE_FORMATS", value: ConstantVal::Uint(34467) },
13535 ConstantSpec { name: c"DONT_CARE", value: ConstantVal::Uint(4352) },
13536 ConstantSpec { name: c"FASTEST", value: ConstantVal::Uint(4353) },
13537 ConstantSpec { name: c"NICEST", value: ConstantVal::Uint(4354) },
13538 ConstantSpec { name: c"GENERATE_MIPMAP_HINT", value: ConstantVal::Uint(33170) },
13539 ConstantSpec { name: c"BYTE", value: ConstantVal::Uint(5120) },
13540 ConstantSpec { name: c"UNSIGNED_BYTE", value: ConstantVal::Uint(5121) },
13541 ConstantSpec { name: c"SHORT", value: ConstantVal::Uint(5122) },
13542 ConstantSpec { name: c"UNSIGNED_SHORT", value: ConstantVal::Uint(5123) },
13543 ConstantSpec { name: c"INT", value: ConstantVal::Uint(5124) },
13544 ConstantSpec { name: c"UNSIGNED_INT", value: ConstantVal::Uint(5125) },
13545 ConstantSpec { name: c"FLOAT", value: ConstantVal::Uint(5126) },
13546 ConstantSpec { name: c"DEPTH_COMPONENT", value: ConstantVal::Uint(6402) },
13547 ConstantSpec { name: c"ALPHA", value: ConstantVal::Uint(6406) },
13548 ConstantSpec { name: c"RGB", value: ConstantVal::Uint(6407) },
13549 ConstantSpec { name: c"RGBA", value: ConstantVal::Uint(6408) },
13550 ConstantSpec { name: c"LUMINANCE", value: ConstantVal::Uint(6409) },
13551 ConstantSpec { name: c"LUMINANCE_ALPHA", value: ConstantVal::Uint(6410) },
13552 ConstantSpec { name: c"UNSIGNED_SHORT_4_4_4_4", value: ConstantVal::Uint(32819) },
13553 ConstantSpec { name: c"UNSIGNED_SHORT_5_5_5_1", value: ConstantVal::Uint(32820) },
13554 ConstantSpec { name: c"UNSIGNED_SHORT_5_6_5", value: ConstantVal::Uint(33635) },
13555 ConstantSpec { name: c"FRAGMENT_SHADER", value: ConstantVal::Uint(35632) },
13556 ConstantSpec { name: c"VERTEX_SHADER", value: ConstantVal::Uint(35633) },
13557 ConstantSpec { name: c"MAX_VERTEX_ATTRIBS", value: ConstantVal::Uint(34921) },
13558 ConstantSpec { name: c"MAX_VERTEX_UNIFORM_VECTORS", value: ConstantVal::Uint(36347) },
13559 ConstantSpec { name: c"MAX_VARYING_VECTORS", value: ConstantVal::Uint(36348) },
13560 ConstantSpec { name: c"MAX_COMBINED_TEXTURE_IMAGE_UNITS", value: ConstantVal::Uint(35661) },
13561 ConstantSpec { name: c"MAX_VERTEX_TEXTURE_IMAGE_UNITS", value: ConstantVal::Uint(35660) },
13562 ConstantSpec { name: c"MAX_TEXTURE_IMAGE_UNITS", value: ConstantVal::Uint(34930) },
13563 ConstantSpec { name: c"MAX_FRAGMENT_UNIFORM_VECTORS", value: ConstantVal::Uint(36349) },
13564 ConstantSpec { name: c"SHADER_TYPE", value: ConstantVal::Uint(35663) },
13565 ConstantSpec { name: c"DELETE_STATUS", value: ConstantVal::Uint(35712) },
13566 ConstantSpec { name: c"LINK_STATUS", value: ConstantVal::Uint(35714) },
13567 ConstantSpec { name: c"VALIDATE_STATUS", value: ConstantVal::Uint(35715) },
13568 ConstantSpec { name: c"ATTACHED_SHADERS", value: ConstantVal::Uint(35717) },
13569 ConstantSpec { name: c"ACTIVE_UNIFORMS", value: ConstantVal::Uint(35718) },
13570 ConstantSpec { name: c"ACTIVE_ATTRIBUTES", value: ConstantVal::Uint(35721) },
13571 ConstantSpec { name: c"SHADING_LANGUAGE_VERSION", value: ConstantVal::Uint(35724) },
13572 ConstantSpec { name: c"CURRENT_PROGRAM", value: ConstantVal::Uint(35725) },
13573 ConstantSpec { name: c"NEVER", value: ConstantVal::Uint(512) },
13574 ConstantSpec { name: c"LESS", value: ConstantVal::Uint(513) },
13575 ConstantSpec { name: c"EQUAL", value: ConstantVal::Uint(514) },
13576 ConstantSpec { name: c"LEQUAL", value: ConstantVal::Uint(515) },
13577 ConstantSpec { name: c"GREATER", value: ConstantVal::Uint(516) },
13578 ConstantSpec { name: c"NOTEQUAL", value: ConstantVal::Uint(517) },
13579 ConstantSpec { name: c"GEQUAL", value: ConstantVal::Uint(518) },
13580 ConstantSpec { name: c"ALWAYS", value: ConstantVal::Uint(519) },
13581 ConstantSpec { name: c"KEEP", value: ConstantVal::Uint(7680) },
13582 ConstantSpec { name: c"REPLACE", value: ConstantVal::Uint(7681) },
13583 ConstantSpec { name: c"INCR", value: ConstantVal::Uint(7682) },
13584 ConstantSpec { name: c"DECR", value: ConstantVal::Uint(7683) },
13585 ConstantSpec { name: c"INVERT", value: ConstantVal::Uint(5386) },
13586 ConstantSpec { name: c"INCR_WRAP", value: ConstantVal::Uint(34055) },
13587 ConstantSpec { name: c"DECR_WRAP", value: ConstantVal::Uint(34056) },
13588 ConstantSpec { name: c"VENDOR", value: ConstantVal::Uint(7936) },
13589 ConstantSpec { name: c"RENDERER", value: ConstantVal::Uint(7937) },
13590 ConstantSpec { name: c"VERSION", value: ConstantVal::Uint(7938) },
13591 ConstantSpec { name: c"NEAREST", value: ConstantVal::Uint(9728) },
13592 ConstantSpec { name: c"LINEAR", value: ConstantVal::Uint(9729) },
13593 ConstantSpec { name: c"NEAREST_MIPMAP_NEAREST", value: ConstantVal::Uint(9984) },
13594 ConstantSpec { name: c"LINEAR_MIPMAP_NEAREST", value: ConstantVal::Uint(9985) },
13595 ConstantSpec { name: c"NEAREST_MIPMAP_LINEAR", value: ConstantVal::Uint(9986) },
13596 ConstantSpec { name: c"LINEAR_MIPMAP_LINEAR", value: ConstantVal::Uint(9987) },
13597 ConstantSpec { name: c"TEXTURE_MAG_FILTER", value: ConstantVal::Uint(10240) },
13598 ConstantSpec { name: c"TEXTURE_MIN_FILTER", value: ConstantVal::Uint(10241) },
13599 ConstantSpec { name: c"TEXTURE_WRAP_S", value: ConstantVal::Uint(10242) },
13600 ConstantSpec { name: c"TEXTURE_WRAP_T", value: ConstantVal::Uint(10243) },
13601 ConstantSpec { name: c"TEXTURE_2D", value: ConstantVal::Uint(3553) },
13602 ConstantSpec { name: c"TEXTURE", value: ConstantVal::Uint(5890) },
13603 ConstantSpec { name: c"TEXTURE_CUBE_MAP", value: ConstantVal::Uint(34067) },
13604 ConstantSpec { name: c"TEXTURE_BINDING_CUBE_MAP", value: ConstantVal::Uint(34068) },
13605 ConstantSpec { name: c"TEXTURE_CUBE_MAP_POSITIVE_X", value: ConstantVal::Uint(34069) },
13606 ConstantSpec { name: c"TEXTURE_CUBE_MAP_NEGATIVE_X", value: ConstantVal::Uint(34070) },
13607 ConstantSpec { name: c"TEXTURE_CUBE_MAP_POSITIVE_Y", value: ConstantVal::Uint(34071) },
13608 ConstantSpec { name: c"TEXTURE_CUBE_MAP_NEGATIVE_Y", value: ConstantVal::Uint(34072) },
13609 ConstantSpec { name: c"TEXTURE_CUBE_MAP_POSITIVE_Z", value: ConstantVal::Uint(34073) },
13610 ConstantSpec { name: c"TEXTURE_CUBE_MAP_NEGATIVE_Z", value: ConstantVal::Uint(34074) },
13611 ConstantSpec { name: c"MAX_CUBE_MAP_TEXTURE_SIZE", value: ConstantVal::Uint(34076) },
13612 ConstantSpec { name: c"TEXTURE0", value: ConstantVal::Uint(33984) },
13613 ConstantSpec { name: c"TEXTURE1", value: ConstantVal::Uint(33985) },
13614 ConstantSpec { name: c"TEXTURE2", value: ConstantVal::Uint(33986) },
13615 ConstantSpec { name: c"TEXTURE3", value: ConstantVal::Uint(33987) },
13616 ConstantSpec { name: c"TEXTURE4", value: ConstantVal::Uint(33988) },
13617 ConstantSpec { name: c"TEXTURE5", value: ConstantVal::Uint(33989) },
13618 ConstantSpec { name: c"TEXTURE6", value: ConstantVal::Uint(33990) },
13619 ConstantSpec { name: c"TEXTURE7", value: ConstantVal::Uint(33991) },
13620 ConstantSpec { name: c"TEXTURE8", value: ConstantVal::Uint(33992) },
13621 ConstantSpec { name: c"TEXTURE9", value: ConstantVal::Uint(33993) },
13622 ConstantSpec { name: c"TEXTURE10", value: ConstantVal::Uint(33994) },
13623 ConstantSpec { name: c"TEXTURE11", value: ConstantVal::Uint(33995) },
13624 ConstantSpec { name: c"TEXTURE12", value: ConstantVal::Uint(33996) },
13625 ConstantSpec { name: c"TEXTURE13", value: ConstantVal::Uint(33997) },
13626 ConstantSpec { name: c"TEXTURE14", value: ConstantVal::Uint(33998) },
13627 ConstantSpec { name: c"TEXTURE15", value: ConstantVal::Uint(33999) },
13628 ConstantSpec { name: c"TEXTURE16", value: ConstantVal::Uint(34000) },
13629 ConstantSpec { name: c"TEXTURE17", value: ConstantVal::Uint(34001) },
13630 ConstantSpec { name: c"TEXTURE18", value: ConstantVal::Uint(34002) },
13631 ConstantSpec { name: c"TEXTURE19", value: ConstantVal::Uint(34003) },
13632 ConstantSpec { name: c"TEXTURE20", value: ConstantVal::Uint(34004) },
13633 ConstantSpec { name: c"TEXTURE21", value: ConstantVal::Uint(34005) },
13634 ConstantSpec { name: c"TEXTURE22", value: ConstantVal::Uint(34006) },
13635 ConstantSpec { name: c"TEXTURE23", value: ConstantVal::Uint(34007) },
13636 ConstantSpec { name: c"TEXTURE24", value: ConstantVal::Uint(34008) },
13637 ConstantSpec { name: c"TEXTURE25", value: ConstantVal::Uint(34009) },
13638 ConstantSpec { name: c"TEXTURE26", value: ConstantVal::Uint(34010) },
13639 ConstantSpec { name: c"TEXTURE27", value: ConstantVal::Uint(34011) },
13640 ConstantSpec { name: c"TEXTURE28", value: ConstantVal::Uint(34012) },
13641 ConstantSpec { name: c"TEXTURE29", value: ConstantVal::Uint(34013) },
13642 ConstantSpec { name: c"TEXTURE30", value: ConstantVal::Uint(34014) },
13643 ConstantSpec { name: c"TEXTURE31", value: ConstantVal::Uint(34015) },
13644 ConstantSpec { name: c"ACTIVE_TEXTURE", value: ConstantVal::Uint(34016) },
13645 ConstantSpec { name: c"REPEAT", value: ConstantVal::Uint(10497) },
13646 ConstantSpec { name: c"CLAMP_TO_EDGE", value: ConstantVal::Uint(33071) },
13647 ConstantSpec { name: c"MIRRORED_REPEAT", value: ConstantVal::Uint(33648) },
13648 ConstantSpec { name: c"FLOAT_VEC2", value: ConstantVal::Uint(35664) },
13649 ConstantSpec { name: c"FLOAT_VEC3", value: ConstantVal::Uint(35665) },
13650 ConstantSpec { name: c"FLOAT_VEC4", value: ConstantVal::Uint(35666) },
13651 ConstantSpec { name: c"INT_VEC2", value: ConstantVal::Uint(35667) },
13652 ConstantSpec { name: c"INT_VEC3", value: ConstantVal::Uint(35668) },
13653 ConstantSpec { name: c"INT_VEC4", value: ConstantVal::Uint(35669) },
13654 ConstantSpec { name: c"BOOL", value: ConstantVal::Uint(35670) },
13655 ConstantSpec { name: c"BOOL_VEC2", value: ConstantVal::Uint(35671) },
13656 ConstantSpec { name: c"BOOL_VEC3", value: ConstantVal::Uint(35672) },
13657 ConstantSpec { name: c"BOOL_VEC4", value: ConstantVal::Uint(35673) },
13658 ConstantSpec { name: c"FLOAT_MAT2", value: ConstantVal::Uint(35674) },
13659 ConstantSpec { name: c"FLOAT_MAT3", value: ConstantVal::Uint(35675) },
13660 ConstantSpec { name: c"FLOAT_MAT4", value: ConstantVal::Uint(35676) },
13661 ConstantSpec { name: c"SAMPLER_2D", value: ConstantVal::Uint(35678) },
13662 ConstantSpec { name: c"SAMPLER_CUBE", value: ConstantVal::Uint(35680) },
13663 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_ENABLED", value: ConstantVal::Uint(34338) },
13664 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_SIZE", value: ConstantVal::Uint(34339) },
13665 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_STRIDE", value: ConstantVal::Uint(34340) },
13666 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_TYPE", value: ConstantVal::Uint(34341) },
13667 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_NORMALIZED", value: ConstantVal::Uint(34922) },
13668 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_POINTER", value: ConstantVal::Uint(34373) },
13669 ConstantSpec { name: c"VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", value: ConstantVal::Uint(34975) },
13670 ConstantSpec { name: c"IMPLEMENTATION_COLOR_READ_TYPE", value: ConstantVal::Uint(35738) },
13671 ConstantSpec { name: c"IMPLEMENTATION_COLOR_READ_FORMAT", value: ConstantVal::Uint(35739) },
13672 ConstantSpec { name: c"COMPILE_STATUS", value: ConstantVal::Uint(35713) },
13673 ConstantSpec { name: c"LOW_FLOAT", value: ConstantVal::Uint(36336) },
13674 ConstantSpec { name: c"MEDIUM_FLOAT", value: ConstantVal::Uint(36337) },
13675 ConstantSpec { name: c"HIGH_FLOAT", value: ConstantVal::Uint(36338) },
13676 ConstantSpec { name: c"LOW_INT", value: ConstantVal::Uint(36339) },
13677 ConstantSpec { name: c"MEDIUM_INT", value: ConstantVal::Uint(36340) },
13678 ConstantSpec { name: c"HIGH_INT", value: ConstantVal::Uint(36341) },
13679 ConstantSpec { name: c"FRAMEBUFFER", value: ConstantVal::Uint(36160) },
13680 ConstantSpec { name: c"RENDERBUFFER", value: ConstantVal::Uint(36161) },
13681 ConstantSpec { name: c"RGBA4", value: ConstantVal::Uint(32854) },
13682 ConstantSpec { name: c"RGB5_A1", value: ConstantVal::Uint(32855) },
13683 ConstantSpec { name: c"RGB565", value: ConstantVal::Uint(36194) },
13684 ConstantSpec { name: c"DEPTH_COMPONENT16", value: ConstantVal::Uint(33189) },
13685 ConstantSpec { name: c"STENCIL_INDEX8", value: ConstantVal::Uint(36168) },
13686 ConstantSpec { name: c"DEPTH_STENCIL", value: ConstantVal::Uint(34041) },
13687 ConstantSpec { name: c"RENDERBUFFER_WIDTH", value: ConstantVal::Uint(36162) },
13688 ConstantSpec { name: c"RENDERBUFFER_HEIGHT", value: ConstantVal::Uint(36163) },
13689 ConstantSpec { name: c"RENDERBUFFER_INTERNAL_FORMAT", value: ConstantVal::Uint(36164) },
13690 ConstantSpec { name: c"RENDERBUFFER_RED_SIZE", value: ConstantVal::Uint(36176) },
13691 ConstantSpec { name: c"RENDERBUFFER_GREEN_SIZE", value: ConstantVal::Uint(36177) },
13692 ConstantSpec { name: c"RENDERBUFFER_BLUE_SIZE", value: ConstantVal::Uint(36178) },
13693 ConstantSpec { name: c"RENDERBUFFER_ALPHA_SIZE", value: ConstantVal::Uint(36179) },
13694 ConstantSpec { name: c"RENDERBUFFER_DEPTH_SIZE", value: ConstantVal::Uint(36180) },
13695 ConstantSpec { name: c"RENDERBUFFER_STENCIL_SIZE", value: ConstantVal::Uint(36181) },
13696 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", value: ConstantVal::Uint(36048) },
13697 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", value: ConstantVal::Uint(36049) },
13698 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", value: ConstantVal::Uint(36050) },
13699 ConstantSpec { name: c"FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", value: ConstantVal::Uint(36051) },
13700 ConstantSpec { name: c"COLOR_ATTACHMENT0", value: ConstantVal::Uint(36064) },
13701 ConstantSpec { name: c"DEPTH_ATTACHMENT", value: ConstantVal::Uint(36096) },
13702 ConstantSpec { name: c"STENCIL_ATTACHMENT", value: ConstantVal::Uint(36128) },
13703 ConstantSpec { name: c"DEPTH_STENCIL_ATTACHMENT", value: ConstantVal::Uint(33306) },
13704 ConstantSpec { name: c"NONE", value: ConstantVal::Uint(0) },
13705 ConstantSpec { name: c"FRAMEBUFFER_COMPLETE", value: ConstantVal::Uint(36053) },
13706 ConstantSpec { name: c"FRAMEBUFFER_INCOMPLETE_ATTACHMENT", value: ConstantVal::Uint(36054) },
13707 ConstantSpec { name: c"FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", value: ConstantVal::Uint(36055) },
13708 ConstantSpec { name: c"FRAMEBUFFER_INCOMPLETE_DIMENSIONS", value: ConstantVal::Uint(36057) },
13709 ConstantSpec { name: c"FRAMEBUFFER_UNSUPPORTED", value: ConstantVal::Uint(36061) },
13710 ConstantSpec { name: c"FRAMEBUFFER_BINDING", value: ConstantVal::Uint(36006) },
13711 ConstantSpec { name: c"RENDERBUFFER_BINDING", value: ConstantVal::Uint(36007) },
13712 ConstantSpec { name: c"MAX_RENDERBUFFER_SIZE", value: ConstantVal::Uint(34024) },
13713 ConstantSpec { name: c"INVALID_FRAMEBUFFER_OPERATION", value: ConstantVal::Uint(1286) },
13714 ConstantSpec { name: c"UNPACK_FLIP_Y_WEBGL", value: ConstantVal::Uint(37440) },
13715 ConstantSpec { name: c"UNPACK_PREMULTIPLY_ALPHA_WEBGL", value: ConstantVal::Uint(37441) },
13716 ConstantSpec { name: c"CONTEXT_LOST_WEBGL", value: ConstantVal::Uint(37442) },
13717 ConstantSpec { name: c"UNPACK_COLORSPACE_CONVERSION_WEBGL", value: ConstantVal::Uint(37443) },
13718 ConstantSpec { name: c"BROWSER_DEFAULT_WEBGL", value: ConstantVal::Uint(37444) }]))[..]
13719])));
13720}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();
13721
13722pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
13723 sConstants.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 { sConstants_specs.get() })[0])])));
13724}
13725pub fn GetProtoObject<D: DomTypes>
13726(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
13727 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WebGLRenderingContext), CreateInterfaceObjects::<D>, rval)
13729}
13730
13731
13732static PrototypeClass: JSClass = JSClass {
13733 name: c"WebGLRenderingContextPrototype".as_ptr(),
13734 flags:
13735 (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
13737 cOps: ptr::null(),
13738 spec: ptr::null(),
13739 ext: ptr::null(),
13740 oOps: ptr::null(),
13741};
13742
13743
13744static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();
13745
13746pub(crate) fn init_interface_object<D: DomTypes>() {
13747 INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
13748 Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
13749 b"function WebGLRenderingContext() {\n [native code]\n}",
13750 PrototypeList::ID::WebGLRenderingContext,
13751 0,
13752 ));
13753}
13754
13755pub fn DefineDOMInterface<D: DomTypes>
13756(cx: SafeJSContext, global: HandleObject){
13757 define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WebGLRenderingContext),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
13758}
13759
13760pub fn ConstructorEnabled<D: DomTypes>
13761(aCx: SafeJSContext, aObj: HandleObject) -> bool{
13762 is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW)
13763}
13764
13765unsafe fn CreateInterfaceObjects<D: DomTypes>
13766(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
13767
13768 rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
13769 prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
13770 assert!(!prototype_proto.is_null());
13771
13772 rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
13773 create_interface_prototype_object::<D>(cx,
13774 global,
13775 prototype_proto.handle(),
13776 &PrototypeClass,
13777 sMethods.get(),
13778 sAttributes.get(),
13779 sConstants.get(),
13780 &[],
13781 prototype.handle_mut());
13782 assert!(!prototype.is_null());
13783 assert!((*cache)[PrototypeList::ID::WebGLRenderingContext as usize].is_null());
13784 (*cache)[PrototypeList::ID::WebGLRenderingContext as usize] = prototype.get();
13785 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::WebGLRenderingContext as isize),
13786 ptr::null_mut(),
13787 prototype.get());
13788
13789 rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
13790 interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));
13791
13792 assert!(!interface_proto.is_null());
13793
13794 rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
13795 create_noncallback_interface_object::<D>(cx,
13796 global,
13797 interface_proto.handle(),
13798 INTERFACE_OBJECT_CLASS.get(),
13799 &[],
13800 &[],
13801 sConstants.get(),
13802 prototype.handle(),
13803 c"WebGLRenderingContext",
13804 0,
13805 &[],
13806 interface.handle_mut());
13807 assert!(!interface.is_null());
13808}
13809
13810
13811 pub(crate) fn init_statics<D: DomTypes>() {
13812 init_interface_object::<D>();
13813 init_domjs_class::<D>();
13814 crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getContextAttributes_methodinfo::<D>();
13815crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_isContextLost_methodinfo::<D>();
13816crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getSupportedExtensions_methodinfo::<D>();
13817crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getExtension_methodinfo::<D>();
13818crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_activeTexture_methodinfo::<D>();
13819crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_attachShader_methodinfo::<D>();
13820crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_bindAttribLocation_methodinfo::<D>();
13821crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_bindBuffer_methodinfo::<D>();
13822crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_bindFramebuffer_methodinfo::<D>();
13823crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_bindRenderbuffer_methodinfo::<D>();
13824crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_bindTexture_methodinfo::<D>();
13825crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_blendColor_methodinfo::<D>();
13826crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_blendEquation_methodinfo::<D>();
13827crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_blendEquationSeparate_methodinfo::<D>();
13828crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_blendFunc_methodinfo::<D>();
13829crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_blendFuncSeparate_methodinfo::<D>();
13830crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_checkFramebufferStatus_methodinfo::<D>();
13831crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_clear_methodinfo::<D>();
13832crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_clearColor_methodinfo::<D>();
13833crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_clearDepth_methodinfo::<D>();
13834crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_clearStencil_methodinfo::<D>();
13835crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_colorMask_methodinfo::<D>();
13836crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_compileShader_methodinfo::<D>();
13837crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_copyTexImage2D_methodinfo::<D>();
13838crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_copyTexSubImage2D_methodinfo::<D>();
13839crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_createBuffer_methodinfo::<D>();
13840crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_createFramebuffer_methodinfo::<D>();
13841crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_createProgram_methodinfo::<D>();
13842crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_createRenderbuffer_methodinfo::<D>();
13843crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_createShader_methodinfo::<D>();
13844crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_createTexture_methodinfo::<D>();
13845crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_cullFace_methodinfo::<D>();
13846crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_deleteBuffer_methodinfo::<D>();
13847crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_deleteFramebuffer_methodinfo::<D>();
13848crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_deleteProgram_methodinfo::<D>();
13849crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_deleteRenderbuffer_methodinfo::<D>();
13850crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_deleteShader_methodinfo::<D>();
13851crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_deleteTexture_methodinfo::<D>();
13852crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_depthFunc_methodinfo::<D>();
13853crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_depthMask_methodinfo::<D>();
13854crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_depthRange_methodinfo::<D>();
13855crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_detachShader_methodinfo::<D>();
13856crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_disable_methodinfo::<D>();
13857crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_disableVertexAttribArray_methodinfo::<D>();
13858crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_drawArrays_methodinfo::<D>();
13859crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_drawElements_methodinfo::<D>();
13860crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_enable_methodinfo::<D>();
13861crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_enableVertexAttribArray_methodinfo::<D>();
13862crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_finish_methodinfo::<D>();
13863crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_flush_methodinfo::<D>();
13864crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_framebufferRenderbuffer_methodinfo::<D>();
13865crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_framebufferTexture2D_methodinfo::<D>();
13866crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_frontFace_methodinfo::<D>();
13867crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_generateMipmap_methodinfo::<D>();
13868crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getActiveAttrib_methodinfo::<D>();
13869crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getActiveUniform_methodinfo::<D>();
13870crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getAttachedShaders_methodinfo::<D>();
13871crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getAttribLocation_methodinfo::<D>();
13872crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getBufferParameter_methodinfo::<D>();
13873crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getParameter_methodinfo::<D>();
13874crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getError_methodinfo::<D>();
13875crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getFramebufferAttachmentParameter_methodinfo::<D>();
13876crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getProgramParameter_methodinfo::<D>();
13877crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getProgramInfoLog_methodinfo::<D>();
13878crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getRenderbufferParameter_methodinfo::<D>();
13879crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getShaderParameter_methodinfo::<D>();
13880crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getShaderPrecisionFormat_methodinfo::<D>();
13881crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getShaderInfoLog_methodinfo::<D>();
13882crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getShaderSource_methodinfo::<D>();
13883crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getTexParameter_methodinfo::<D>();
13884crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getUniform_methodinfo::<D>();
13885crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getUniformLocation_methodinfo::<D>();
13886crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getVertexAttrib_methodinfo::<D>();
13887crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_getVertexAttribOffset_methodinfo::<D>();
13888crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_hint_methodinfo::<D>();
13889crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_isBuffer_methodinfo::<D>();
13890crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_isEnabled_methodinfo::<D>();
13891crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_isFramebuffer_methodinfo::<D>();
13892crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_isProgram_methodinfo::<D>();
13893crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_isRenderbuffer_methodinfo::<D>();
13894crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_isShader_methodinfo::<D>();
13895crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_isTexture_methodinfo::<D>();
13896crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_lineWidth_methodinfo::<D>();
13897crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_linkProgram_methodinfo::<D>();
13898crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_pixelStorei_methodinfo::<D>();
13899crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_polygonOffset_methodinfo::<D>();
13900crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_renderbufferStorage_methodinfo::<D>();
13901crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_sampleCoverage_methodinfo::<D>();
13902crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_scissor_methodinfo::<D>();
13903crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_shaderSource_methodinfo::<D>();
13904crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_stencilFunc_methodinfo::<D>();
13905crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_stencilFuncSeparate_methodinfo::<D>();
13906crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_stencilMask_methodinfo::<D>();
13907crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_stencilMaskSeparate_methodinfo::<D>();
13908crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_stencilOp_methodinfo::<D>();
13909crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_stencilOpSeparate_methodinfo::<D>();
13910crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_texParameterf_methodinfo::<D>();
13911crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_texParameteri_methodinfo::<D>();
13912crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform1f_methodinfo::<D>();
13913crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform2f_methodinfo::<D>();
13914crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform3f_methodinfo::<D>();
13915crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform4f_methodinfo::<D>();
13916crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform1i_methodinfo::<D>();
13917crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform2i_methodinfo::<D>();
13918crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform3i_methodinfo::<D>();
13919crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform4i_methodinfo::<D>();
13920crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_useProgram_methodinfo::<D>();
13921crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_validateProgram_methodinfo::<D>();
13922crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttrib1f_methodinfo::<D>();
13923crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttrib2f_methodinfo::<D>();
13924crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttrib3f_methodinfo::<D>();
13925crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttrib4f_methodinfo::<D>();
13926crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttrib1fv_methodinfo::<D>();
13927crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttrib2fv_methodinfo::<D>();
13928crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttrib3fv_methodinfo::<D>();
13929crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttrib4fv_methodinfo::<D>();
13930crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_vertexAttribPointer_methodinfo::<D>();
13931crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_viewport_methodinfo::<D>();
13932crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_makeXRCompatible_methodinfo::<D>();
13933crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_bufferData_methodinfo::<D>();
13934crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_bufferSubData_methodinfo::<D>();
13935crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_compressedTexImage2D_methodinfo::<D>();
13936crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_compressedTexSubImage2D_methodinfo::<D>();
13937crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_readPixels_methodinfo::<D>();
13938crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_texImage2D_methodinfo::<D>();
13939crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_texSubImage2D_methodinfo::<D>();
13940crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform1fv_methodinfo::<D>();
13941crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform2fv_methodinfo::<D>();
13942crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform3fv_methodinfo::<D>();
13943crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform4fv_methodinfo::<D>();
13944crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform1iv_methodinfo::<D>();
13945crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform2iv_methodinfo::<D>();
13946crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform3iv_methodinfo::<D>();
13947crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniform4iv_methodinfo::<D>();
13948crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniformMatrix2fv_methodinfo::<D>();
13949crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniformMatrix3fv_methodinfo::<D>();
13950crate::codegen::GenericBindings::WebGLRenderingContextBinding::WebGLRenderingContext_Binding::init_uniformMatrix4fv_methodinfo::<D>();
13951 init_canvas_getterinfo::<D>();
13952init_drawingBufferWidth_getterinfo::<D>();
13953init_drawingBufferHeight_getterinfo::<D>();
13954
13955
13956 init_sMethods_specs::<D>();
13957init_sMethods_prefs::<D>();
13958init_sAttributes_specs::<D>();
13959init_sAttributes_prefs::<D>();
13960init_sConstants_specs::<D>();
13961init_sConstants_prefs::<D>();
13962 }
13963 }