1#![allow(non_upper_case_globals)]
2#![allow(clippy::too_many_arguments)]
3#![allow(clippy::trivially_copy_pass_by_ref)]
4#![allow(clippy::unreadable_literal)]
5#![allow(clippy::missing_safety_doc)]
6#![allow(clippy::pedantic)] // For anyone using pedantic and a source dep, this is needed
7
8use core::fmt::Debug;
9use core::hash::Hash;
10use std::collections::HashSet;
11
12mod version;
13pub use version::Version;
14
15#[cfg(any(not(target_arch = "wasm32"), target_os = "emscripten"))]
16mod native;
17#[cfg(any(not(target_arch = "wasm32"), target_os = "emscripten"))]
18pub use native::*;
19#[cfg(any(not(target_arch = "wasm32"), target_os = "emscripten"))]
20mod gl46;
21
22#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
23#[path = "web_sys.rs"]
24mod web;
25#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
26pub use web::*;
27
28pub type Shader = <Context as HasContext>::Shader;
29pub type Program = <Context as HasContext>::Program;
30pub type Buffer = <Context as HasContext>::Buffer;
31pub type VertexArray = <Context as HasContext>::VertexArray;
32pub type Texture = <Context as HasContext>::Texture;
33pub type Sampler = <Context as HasContext>::Sampler;
34pub type Fence = <Context as HasContext>::Fence;
35pub type Framebuffer = <Context as HasContext>::Framebuffer;
36pub type Renderbuffer = <Context as HasContext>::Renderbuffer;
37pub type Query = <Context as HasContext>::Query;
38pub type UniformLocation = <Context as HasContext>::UniformLocation;
39pub type TransformFeedback = <Context as HasContext>::TransformFeedback;
40pub type DebugCallback = Box<dyn Fn(u32, u32, u32, u32, &str) + Send + Sync>;
41
42pub struct ActiveUniform {
43 pub size: i32,
44 pub utype: u32,
45 pub name: String,
46}
47
48pub struct ActiveAttribute {
49 pub size: i32,
50 pub atype: u32,
51 pub name: String,
52}
53
54pub struct ActiveTransformFeedback {
55 pub size: i32,
56 pub tftype: u32,
57 pub name: String,
58}
59
60#[derive(Debug)]
61pub struct ShaderPrecisionFormat {
62 /// The base 2 log of the absolute value of the minimum value that can be represented
63 pub range_min: i32,
64 /// The base 2 log of the absolute value of the maximum value that can be represented.
65 pub range_max: i32,
66 /// The number of bits of precision that can be represented.
67 /// For integer formats this value is always 0.
68 pub precision: i32,
69}
70
71impl ShaderPrecisionFormat {
72 /// Returns OpenGL standard precision that most desktop hardware support
73 pub fn common_desktop_hardware(precision_type: u32, is_embedded: bool) -> Self {
74 let (range_min, range_max, precision) = match precision_type {
75 LOW_INT | MEDIUM_INT | HIGH_INT => {
76 // Precision: For integer formats this value is always 0
77 if is_embedded {
78 // These values are for a 32-bit twos-complement integer format.
79 (31, 30, 0)
80 } else {
81 // Range: from -2^24 to 2^24
82 (24, 24, 0)
83 }
84 }
85 // IEEE 754 single-precision floating-point
86 // Range: from -2^127 to 2^127
87 // Significand precision: 23 bits
88 LOW_FLOAT | MEDIUM_FLOAT | HIGH_FLOAT => (127, 127, 23),
89 _ => unreachable!("invalid precision"),
90 };
91 Self {
92 range_min,
93 range_max,
94 precision,
95 }
96 }
97}
98
99#[allow(dead_code)]
100#[derive(Debug)]
101pub struct DebugMessageLogEntry {
102 source: u32,
103 msg_type: u32,
104 id: u32,
105 severity: u32,
106 message: String,
107}
108
109pub enum PixelPackData<'a> {
110 BufferOffset(u32),
111 Slice(Option<&'a mut [u8]>),
112}
113
114pub enum PixelUnpackData<'a> {
115 BufferOffset(u32),
116 Slice(Option<&'a [u8]>),
117}
118
119pub enum CompressedPixelUnpackData<'a> {
120 BufferRange(core::ops::Range<u32>),
121 Slice(&'a [u8]),
122}
123
124pub struct ProgramBinary {
125 pub buffer: Vec<u8>,
126 pub format: u32,
127}
128
129/// A trait for types that can be used as a context for OpenGL, OpenGL ES, and WebGL functions.
130///
131/// This trait is sealed and cannot be implemented outside of this crate.
132///
133/// # Safety
134///
135/// All GL API usage must be valid. For example, each function call should follow the rules in the
136/// relevant GL specification for the type of context being used. This crate doesn't enforce these
137/// rules, so it is up to the caller to ensure they're followed.
138///
139/// The context implementing this trait must be current when it is dropped. This is necessary to
140/// ensure that certain context state can be deleted on the correct thread. Usually this is only
141/// a concern for desktop GL contexts that are shared between threads.
142pub trait HasContext: __private::Sealed {
143 type Shader: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
144 type Program: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
145 type Buffer: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
146 type VertexArray: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
147 type Texture: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
148 type Sampler: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
149 type Fence: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
150 type Framebuffer: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
151 type Renderbuffer: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
152 type Query: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
153 type TransformFeedback: Copy + Clone + Debug + Eq + Hash + Ord + PartialEq + PartialOrd;
154 type UniformLocation: Clone + Debug;
155
156 fn supported_extensions(&self) -> &HashSet<String>;
157
158 fn supports_debug(&self) -> bool;
159
160 fn version(&self) -> &Version;
161
162 unsafe fn create_framebuffer(&self) -> Result<Self::Framebuffer, String>;
163
164 unsafe fn create_named_framebuffer(&self) -> Result<Self::Framebuffer, String>;
165
166 unsafe fn is_framebuffer(&self, framebuffer: Self::Framebuffer) -> bool;
167
168 unsafe fn create_query(&self) -> Result<Self::Query, String>;
169
170 unsafe fn create_renderbuffer(&self) -> Result<Self::Renderbuffer, String>;
171
172 unsafe fn is_renderbuffer(&self, renderbuffer: Self::Renderbuffer) -> bool;
173
174 unsafe fn create_sampler(&self) -> Result<Self::Sampler, String>;
175
176 unsafe fn create_shader(&self, shader_type: u32) -> Result<Self::Shader, String>;
177
178 unsafe fn is_shader(&self, shader: Self::Shader) -> bool;
179
180 unsafe fn create_texture(&self) -> Result<Self::Texture, String>;
181
182 unsafe fn create_named_texture(&self, target: u32) -> Result<Self::Texture, String>;
183
184 unsafe fn is_texture(&self, texture: Self::Texture) -> bool;
185
186 unsafe fn delete_shader(&self, shader: Self::Shader);
187
188 unsafe fn shader_source(&self, shader: Self::Shader, source: &str);
189
190 unsafe fn compile_shader(&self, shader: Self::Shader);
191
192 unsafe fn get_shader_completion_status(&self, shader: Self::Shader) -> bool;
193
194 unsafe fn get_shader_compile_status(&self, shader: Self::Shader) -> bool;
195
196 unsafe fn get_shader_info_log(&self, shader: Self::Shader) -> String;
197
198 unsafe fn get_shader_precision_format(
199 &self,
200 shader_type: u32,
201 precision_mode: u32,
202 ) -> Option<ShaderPrecisionFormat>;
203
204 unsafe fn get_tex_image(
205 &self,
206 target: u32,
207 level: i32,
208 format: u32,
209 ty: u32,
210 pixels: PixelPackData,
211 );
212
213 unsafe fn create_program(&self) -> Result<Self::Program, String>;
214
215 unsafe fn is_program(&self, program: Self::Program) -> bool;
216
217 unsafe fn delete_program(&self, program: Self::Program);
218
219 unsafe fn attach_shader(&self, program: Self::Program, shader: Self::Shader);
220
221 unsafe fn detach_shader(&self, program: Self::Program, shader: Self::Shader);
222
223 unsafe fn link_program(&self, program: Self::Program);
224
225 unsafe fn validate_program(&self, program: Self::Program);
226
227 unsafe fn get_program_completion_status(&self, program: Self::Program) -> bool;
228
229 unsafe fn get_program_validate_status(&self, program: Self::Program) -> bool;
230
231 unsafe fn get_program_link_status(&self, program: Self::Program) -> bool;
232
233 unsafe fn get_program_parameter_i32(&self, program: Self::Program, parameter: u32) -> i32;
234
235 unsafe fn get_program_info_log(&self, program: Self::Program) -> String;
236
237 unsafe fn get_program_resource_i32(
238 &self,
239 program: Self::Program,
240 interface: u32,
241 index: u32,
242 properties: &[u32],
243 ) -> Vec<i32>;
244
245 unsafe fn program_uniform_1_i32(
246 &self,
247 program: Self::Program,
248 location: Option<&Self::UniformLocation>,
249 x: i32,
250 );
251
252 unsafe fn program_uniform_2_i32(
253 &self,
254 program: Self::Program,
255 location: Option<&Self::UniformLocation>,
256 x: i32,
257 y: i32,
258 );
259
260 unsafe fn program_uniform_3_i32(
261 &self,
262 program: Self::Program,
263 location: Option<&Self::UniformLocation>,
264 x: i32,
265 y: i32,
266 z: i32,
267 );
268
269 unsafe fn program_uniform_4_i32(
270 &self,
271 program: Self::Program,
272 location: Option<&Self::UniformLocation>,
273 x: i32,
274 y: i32,
275 z: i32,
276 w: i32,
277 );
278
279 unsafe fn program_uniform_1_i32_slice(
280 &self,
281 program: Self::Program,
282 location: Option<&Self::UniformLocation>,
283 v: &[i32],
284 );
285
286 unsafe fn program_uniform_2_i32_slice(
287 &self,
288 program: Self::Program,
289 location: Option<&Self::UniformLocation>,
290 v: &[i32],
291 );
292
293 unsafe fn program_uniform_3_i32_slice(
294 &self,
295 program: Self::Program,
296 location: Option<&Self::UniformLocation>,
297 v: &[i32],
298 );
299
300 unsafe fn program_uniform_4_i32_slice(
301 &self,
302 program: Self::Program,
303 location: Option<&Self::UniformLocation>,
304 v: &[i32],
305 );
306
307 unsafe fn program_uniform_1_u32(
308 &self,
309 program: Self::Program,
310 location: Option<&Self::UniformLocation>,
311 x: u32,
312 );
313
314 unsafe fn program_uniform_2_u32(
315 &self,
316 program: Self::Program,
317 location: Option<&Self::UniformLocation>,
318 x: u32,
319 y: u32,
320 );
321
322 unsafe fn program_uniform_3_u32(
323 &self,
324 program: Self::Program,
325 location: Option<&Self::UniformLocation>,
326 x: u32,
327 y: u32,
328 z: u32,
329 );
330
331 unsafe fn program_uniform_4_u32(
332 &self,
333 program: Self::Program,
334 location: Option<&Self::UniformLocation>,
335 x: u32,
336 y: u32,
337 z: u32,
338 w: u32,
339 );
340
341 unsafe fn program_uniform_1_u32_slice(
342 &self,
343 program: Self::Program,
344 location: Option<&Self::UniformLocation>,
345 v: &[u32],
346 );
347
348 unsafe fn program_uniform_2_u32_slice(
349 &self,
350 program: Self::Program,
351 location: Option<&Self::UniformLocation>,
352 v: &[u32],
353 );
354
355 unsafe fn program_uniform_3_u32_slice(
356 &self,
357 program: Self::Program,
358 location: Option<&Self::UniformLocation>,
359 v: &[u32],
360 );
361
362 unsafe fn program_uniform_4_u32_slice(
363 &self,
364 program: Self::Program,
365 location: Option<&Self::UniformLocation>,
366 v: &[u32],
367 );
368
369 unsafe fn program_uniform_1_f32(
370 &self,
371 program: Self::Program,
372 location: Option<&Self::UniformLocation>,
373 x: f32,
374 );
375
376 unsafe fn program_uniform_2_f32(
377 &self,
378 program: Self::Program,
379 location: Option<&Self::UniformLocation>,
380 x: f32,
381 y: f32,
382 );
383
384 unsafe fn program_uniform_3_f32(
385 &self,
386 program: Self::Program,
387 location: Option<&Self::UniformLocation>,
388 x: f32,
389 y: f32,
390 z: f32,
391 );
392
393 unsafe fn program_uniform_4_f32(
394 &self,
395 program: Self::Program,
396 location: Option<&Self::UniformLocation>,
397 x: f32,
398 y: f32,
399 z: f32,
400 w: f32,
401 );
402
403 unsafe fn program_uniform_1_f32_slice(
404 &self,
405 program: Self::Program,
406 location: Option<&Self::UniformLocation>,
407 v: &[f32],
408 );
409
410 unsafe fn program_uniform_2_f32_slice(
411 &self,
412 program: Self::Program,
413 location: Option<&Self::UniformLocation>,
414 v: &[f32],
415 );
416
417 unsafe fn program_uniform_3_f32_slice(
418 &self,
419 program: Self::Program,
420 location: Option<&Self::UniformLocation>,
421 v: &[f32],
422 );
423
424 unsafe fn program_uniform_4_f32_slice(
425 &self,
426 program: Self::Program,
427 location: Option<&Self::UniformLocation>,
428 v: &[f32],
429 );
430
431 unsafe fn program_uniform_matrix_2_f32_slice(
432 &self,
433 program: Self::Program,
434 location: Option<&Self::UniformLocation>,
435 transpose: bool,
436 v: &[f32],
437 );
438
439 unsafe fn program_uniform_matrix_2x3_f32_slice(
440 &self,
441 program: Self::Program,
442 location: Option<&Self::UniformLocation>,
443 transpose: bool,
444 v: &[f32],
445 );
446
447 unsafe fn program_uniform_matrix_2x4_f32_slice(
448 &self,
449 program: Self::Program,
450 location: Option<&Self::UniformLocation>,
451 transpose: bool,
452 v: &[f32],
453 );
454
455 unsafe fn program_uniform_matrix_3x2_f32_slice(
456 &self,
457 program: Self::Program,
458 location: Option<&Self::UniformLocation>,
459 transpose: bool,
460 v: &[f32],
461 );
462
463 unsafe fn program_uniform_matrix_3_f32_slice(
464 &self,
465 program: Self::Program,
466 location: Option<&Self::UniformLocation>,
467 transpose: bool,
468 v: &[f32],
469 );
470
471 unsafe fn program_uniform_matrix_3x4_f32_slice(
472 &self,
473 program: Self::Program,
474 location: Option<&Self::UniformLocation>,
475 transpose: bool,
476 v: &[f32],
477 );
478
479 unsafe fn program_uniform_matrix_4x2_f32_slice(
480 &self,
481 program: Self::Program,
482 location: Option<&Self::UniformLocation>,
483 transpose: bool,
484 v: &[f32],
485 );
486
487 unsafe fn program_uniform_matrix_4x3_f32_slice(
488 &self,
489 program: Self::Program,
490 location: Option<&Self::UniformLocation>,
491 transpose: bool,
492 v: &[f32],
493 );
494
495 unsafe fn program_uniform_matrix_4_f32_slice(
496 &self,
497 program: Self::Program,
498 location: Option<&Self::UniformLocation>,
499 transpose: bool,
500 v: &[f32],
501 );
502
503 unsafe fn program_binary_retrievable_hint(&self, program: Self::Program, value: bool);
504
505 unsafe fn get_program_binary(&self, program: Self::Program) -> Option<ProgramBinary>;
506
507 unsafe fn program_binary(&self, program: Self::Program, binary: &ProgramBinary);
508
509 unsafe fn get_active_uniforms(&self, program: Self::Program) -> u32;
510
511 #[doc(alias = "GetActiveUniformsiv")]
512 unsafe fn get_active_uniforms_parameter(
513 &self,
514 program: Self::Program,
515 uniforms: &[u32],
516 pname: u32,
517 ) -> Vec<i32>;
518
519 unsafe fn get_active_uniform(
520 &self,
521 program: Self::Program,
522 index: u32,
523 ) -> Option<ActiveUniform>;
524
525 unsafe fn use_program(&self, program: Option<Self::Program>);
526
527 unsafe fn create_buffer(&self) -> Result<Self::Buffer, String>;
528
529 unsafe fn create_named_buffer(&self) -> Result<Self::Buffer, String>;
530
531 unsafe fn is_buffer(&self, buffer: Self::Buffer) -> bool;
532
533 unsafe fn bind_buffer(&self, target: u32, buffer: Option<Self::Buffer>);
534
535 unsafe fn bind_buffer_base(&self, target: u32, index: u32, buffer: Option<Self::Buffer>);
536
537 unsafe fn bind_buffer_range(
538 &self,
539 target: u32,
540 index: u32,
541 buffer: Option<Self::Buffer>,
542 offset: i32,
543 size: i32,
544 );
545
546 unsafe fn bind_vertex_buffer(
547 &self,
548 binding_index: u32,
549 buffer: Option<Buffer>,
550 offset: i32,
551 stride: i32,
552 );
553
554 unsafe fn bind_framebuffer(&self, target: u32, framebuffer: Option<Self::Framebuffer>);
555
556 unsafe fn bind_renderbuffer(&self, target: u32, renderbuffer: Option<Self::Renderbuffer>);
557
558 unsafe fn blit_framebuffer(
559 &self,
560 src_x0: i32,
561 src_y0: i32,
562 src_x1: i32,
563 src_y1: i32,
564 dst_x0: i32,
565 dst_y0: i32,
566 dst_x1: i32,
567 dst_y1: i32,
568 mask: u32,
569 filter: u32,
570 );
571
572 unsafe fn blit_named_framebuffer(
573 &self,
574 read_buffer: Option<Self::Framebuffer>,
575 draw_buffer: Option<Self::Framebuffer>,
576 src_x0: i32,
577 src_y0: i32,
578 src_x1: i32,
579 src_y1: i32,
580 dst_x0: i32,
581 dst_y0: i32,
582 dst_x1: i32,
583 dst_y1: i32,
584 mask: u32,
585 filter: u32,
586 );
587
588 unsafe fn create_vertex_array(&self) -> Result<Self::VertexArray, String>;
589
590 unsafe fn create_named_vertex_array(&self) -> Result<Self::VertexArray, String>;
591
592 unsafe fn delete_vertex_array(&self, vertex_array: Self::VertexArray);
593
594 unsafe fn bind_vertex_array(&self, vertex_array: Option<Self::VertexArray>);
595
596 unsafe fn clear_color(&self, red: f32, green: f32, blue: f32, alpha: f32);
597
598 unsafe fn supports_f64_precision(&self) -> bool;
599
600 unsafe fn clear_depth_f64(&self, depth: f64);
601
602 unsafe fn clear_depth_f32(&self, depth: f32);
603
604 unsafe fn clear_depth(&self, depth: f64);
605
606 unsafe fn clear_stencil(&self, stencil: i32);
607
608 unsafe fn clear(&self, mask: u32);
609
610 unsafe fn patch_parameter_i32(&self, parameter: u32, value: i32);
611
612 unsafe fn pixel_store_i32(&self, parameter: u32, value: i32);
613
614 unsafe fn pixel_store_bool(&self, parameter: u32, value: bool);
615
616 unsafe fn get_frag_data_location(&self, program: Self::Program, name: &str) -> i32;
617
618 unsafe fn bind_frag_data_location(&self, program: Self::Program, color_number: u32, name: &str);
619
620 unsafe fn buffer_data_size(&self, target: u32, size: i32, usage: u32);
621
622 unsafe fn named_buffer_data_size(&self, buffer: Self::Buffer, size: i32, usage: u32);
623
624 unsafe fn buffer_data_u8_slice(&self, target: u32, data: &[u8], usage: u32);
625
626 unsafe fn named_buffer_data_u8_slice(&self, buffer: Self::Buffer, data: &[u8], usage: u32);
627
628 unsafe fn buffer_sub_data_u8_slice(&self, target: u32, offset: i32, src_data: &[u8]);
629
630 unsafe fn named_buffer_sub_data_u8_slice(
631 &self,
632 buffer: Self::Buffer,
633 offset: i32,
634 src_data: &[u8],
635 );
636
637 unsafe fn get_buffer_sub_data(&self, target: u32, offset: i32, dst_data: &mut [u8]);
638
639 unsafe fn buffer_storage(&self, target: u32, size: i32, data: Option<&[u8]>, flags: u32);
640
641 unsafe fn check_framebuffer_status(&self, target: u32) -> u32;
642
643 unsafe fn check_named_framebuffer_status(
644 &self,
645 framebuffer: Option<Self::Framebuffer>,
646 target: u32,
647 ) -> u32;
648
649 unsafe fn clear_buffer_i32_slice(&self, target: u32, draw_buffer: u32, values: &[i32]);
650
651 unsafe fn clear_buffer_u32_slice(&self, target: u32, draw_buffer: u32, values: &[u32]);
652
653 unsafe fn clear_buffer_f32_slice(&self, target: u32, draw_buffer: u32, values: &[f32]);
654
655 unsafe fn clear_buffer_depth_stencil(
656 &self,
657 target: u32,
658 draw_buffer: u32,
659 depth: f32,
660 stencil: i32,
661 );
662
663 unsafe fn clear_named_framebuffer_i32_slice(
664 &self,
665 framebuffer: Option<Self::Framebuffer>,
666 target: u32,
667 draw_buffer: u32,
668 values: &[i32],
669 );
670
671 unsafe fn clear_named_framebuffer_u32_slice(
672 &self,
673 framebuffer: Option<Self::Framebuffer>,
674 target: u32,
675 draw_buffer: u32,
676 values: &[u32],
677 );
678
679 unsafe fn clear_named_framebuffer_f32_slice(
680 &self,
681 framebuffer: Option<Self::Framebuffer>,
682 target: u32,
683 draw_buffer: u32,
684 values: &[f32],
685 );
686
687 unsafe fn clear_named_framebuffer_depth_stencil(
688 &self,
689 framebuffer: Option<Self::Framebuffer>,
690 target: u32,
691 draw_buffer: u32,
692 depth: f32,
693 stencil: i32,
694 );
695
696 unsafe fn client_wait_sync(&self, fence: Self::Fence, flags: u32, timeout: i32) -> u32;
697
698 unsafe fn get_sync_parameter_i32(&self, fence: Self::Fence, parameter: u32) -> i32;
699
700 unsafe fn wait_sync(&self, fence: Self::Fence, flags: u32, timeout: u64);
701
702 unsafe fn copy_buffer_sub_data(
703 &self,
704 src_target: u32,
705 dst_target: u32,
706 src_offset: i32,
707 dst_offset: i32,
708 size: i32,
709 );
710
711 unsafe fn copy_image_sub_data(
712 &self,
713 src_name: Self::Texture,
714 src_target: u32,
715 src_level: i32,
716 src_x: i32,
717 src_y: i32,
718 src_z: i32,
719 dst_name: Self::Texture,
720 dst_target: u32,
721 dst_level: i32,
722 dst_x: i32,
723 dst_y: i32,
724 dst_z: i32,
725 src_width: i32,
726 src_height: i32,
727 src_depth: i32,
728 );
729
730 unsafe fn copy_tex_image_2d(
731 &self,
732 target: u32,
733 level: i32,
734 internal_format: u32,
735 x: i32,
736 y: i32,
737 width: i32,
738 height: i32,
739 border: i32,
740 );
741
742 unsafe fn copy_tex_sub_image_2d(
743 &self,
744 target: u32,
745 level: i32,
746 x_offset: i32,
747 y_offset: i32,
748 x: i32,
749 y: i32,
750 width: i32,
751 height: i32,
752 );
753
754 unsafe fn copy_tex_sub_image_3d(
755 &self,
756 target: u32,
757 level: i32,
758 x_offset: i32,
759 y_offset: i32,
760 z_offset: i32,
761 x: i32,
762 y: i32,
763 width: i32,
764 height: i32,
765 );
766
767 unsafe fn delete_buffer(&self, buffer: Self::Buffer);
768
769 unsafe fn delete_framebuffer(&self, framebuffer: Self::Framebuffer);
770
771 unsafe fn delete_query(&self, query: Self::Query);
772
773 unsafe fn delete_renderbuffer(&self, renderbuffer: Self::Renderbuffer);
774
775 unsafe fn delete_sampler(&self, texture: Self::Sampler);
776
777 unsafe fn delete_sync(&self, fence: Self::Fence);
778
779 unsafe fn delete_texture(&self, texture: Self::Texture);
780
781 unsafe fn disable(&self, parameter: u32);
782
783 unsafe fn disable_draw_buffer(&self, parameter: u32, draw_buffer: u32);
784
785 unsafe fn disable_vertex_attrib_array(&self, index: u32);
786
787 unsafe fn dispatch_compute(&self, groups_x: u32, groups_y: u32, groups_z: u32);
788
789 unsafe fn dispatch_compute_indirect(&self, offset: i32);
790
791 unsafe fn draw_arrays(&self, mode: u32, first: i32, count: i32);
792
793 unsafe fn draw_arrays_instanced(&self, mode: u32, first: i32, count: i32, instance_count: i32);
794
795 unsafe fn draw_arrays_instanced_base_instance(
796 &self,
797 mode: u32,
798 first: i32,
799 count: i32,
800 instance_count: i32,
801 base_instance: u32,
802 );
803
804 unsafe fn draw_arrays_indirect_offset(&self, mode: u32, offset: i32);
805
806 unsafe fn draw_buffer(&self, buffer: u32);
807
808 unsafe fn named_framebuffer_draw_buffer(
809 &self,
810 framebuffer: Option<Self::Framebuffer>,
811 draw_buffer: u32,
812 );
813
814 unsafe fn named_framebuffer_draw_buffers(
815 &self,
816 framebuffer: Option<Self::Framebuffer>,
817 buffers: &[u32],
818 );
819
820 unsafe fn draw_buffers(&self, buffers: &[u32]);
821
822 unsafe fn draw_elements(&self, mode: u32, count: i32, element_type: u32, offset: i32);
823
824 unsafe fn draw_elements_base_vertex(
825 &self,
826 mode: u32,
827 count: i32,
828 element_type: u32,
829 offset: i32,
830 base_vertex: i32,
831 );
832
833 unsafe fn draw_elements_instanced(
834 &self,
835 mode: u32,
836 count: i32,
837 element_type: u32,
838 offset: i32,
839 instance_count: i32,
840 );
841
842 unsafe fn draw_elements_instanced_base_vertex(
843 &self,
844 mode: u32,
845 count: i32,
846 element_type: u32,
847 offset: i32,
848 instance_count: i32,
849 base_vertex: i32,
850 );
851
852 unsafe fn draw_elements_instanced_base_vertex_base_instance(
853 &self,
854 mode: u32,
855 count: i32,
856 element_type: u32,
857 offset: i32,
858 instance_count: i32,
859 base_vertex: i32,
860 base_instance: u32,
861 );
862
863 unsafe fn draw_elements_indirect_offset(&self, mode: u32, element_type: u32, offset: i32);
864
865 unsafe fn enable(&self, parameter: u32);
866
867 unsafe fn is_enabled(&self, parameter: u32) -> bool;
868
869 unsafe fn enable_draw_buffer(&self, parameter: u32, draw_buffer: u32);
870
871 unsafe fn enable_vertex_array_attrib(&self, vao: Self::VertexArray, index: u32);
872
873 unsafe fn enable_vertex_attrib_array(&self, index: u32);
874
875 unsafe fn flush(&self);
876
877 unsafe fn framebuffer_renderbuffer(
878 &self,
879 target: u32,
880 attachment: u32,
881 renderbuffer_target: u32,
882 renderbuffer: Option<Self::Renderbuffer>,
883 );
884
885 unsafe fn framebuffer_texture(
886 &self,
887 target: u32,
888 attachment: u32,
889 texture: Option<Self::Texture>,
890 level: i32,
891 );
892
893 unsafe fn framebuffer_texture_2d(
894 &self,
895 target: u32,
896 attachment: u32,
897 texture_target: u32,
898 texture: Option<Self::Texture>,
899 level: i32,
900 );
901
902 unsafe fn framebuffer_texture_3d(
903 &self,
904 target: u32,
905 attachment: u32,
906 texture_target: u32,
907 texture: Option<Self::Texture>,
908 level: i32,
909 layer: i32,
910 );
911
912 unsafe fn framebuffer_texture_layer(
913 &self,
914 target: u32,
915 attachment: u32,
916 texture: Option<Self::Texture>,
917 level: i32,
918 layer: i32,
919 );
920
921 unsafe fn named_framebuffer_renderbuffer(
922 &self,
923 framebuffer: Option<Self::Framebuffer>,
924 attachment: u32,
925 renderbuffer_target: u32,
926 renderbuffer: Option<Self::Renderbuffer>,
927 );
928
929 unsafe fn named_framebuffer_texture(
930 &self,
931 framebuffer: Option<Self::Framebuffer>,
932 attachment: u32,
933 texture: Option<Self::Texture>,
934 level: i32,
935 );
936
937 unsafe fn named_framebuffer_texture_layer(
938 &self,
939 framebuffer: Option<Self::Framebuffer>,
940 attachment: u32,
941 texture: Option<Self::Texture>,
942 level: i32,
943 layer: i32,
944 );
945
946 unsafe fn front_face(&self, value: u32);
947
948 unsafe fn get_error(&self) -> u32;
949
950 unsafe fn get_tex_parameter_i32(&self, target: u32, parameter: u32) -> i32;
951
952 unsafe fn get_tex_parameter_f32(&self, target: u32, parameter: u32) -> f32;
953
954 unsafe fn get_buffer_parameter_i32(&self, target: u32, parameter: u32) -> i32;
955
956 #[doc(alias = "glGetBooleanv")]
957 unsafe fn get_parameter_bool(&self, parameter: u32) -> bool;
958
959 #[doc(alias = "glGetBooleanv")]
960 unsafe fn get_parameter_bool_array<const N: usize>(&self, parameter: u32) -> [bool; N];
961
962 #[doc(alias = "glGetIntegerv")]
963 unsafe fn get_parameter_i32(&self, parameter: u32) -> i32;
964
965 #[doc(alias = "glGetIntegerv")]
966 unsafe fn get_parameter_i32_slice(&self, parameter: u32, out: &mut [i32]);
967
968 #[doc(alias = "glGetInteger64v")]
969 unsafe fn get_parameter_i64(&self, parameter: u32) -> i64;
970
971 #[doc(alias = "glGetInteger64v")]
972 unsafe fn get_parameter_i64_slice(&self, parameter: u32, out: &mut [i64]);
973
974 #[doc(alias = "glGetInteger64i_v")]
975 unsafe fn get_parameter_indexed_i64(&self, parameter: u32, index: u32) -> i64;
976
977 #[doc(alias = "glGetFloatv")]
978 unsafe fn get_parameter_f32(&self, parameter: u32) -> f32;
979
980 #[doc(alias = "glGetFloatv")]
981 unsafe fn get_parameter_f32_slice(&self, parameter: u32, out: &mut [f32]);
982
983 #[doc(alias = "glGetIntegeri_v")]
984 unsafe fn get_parameter_indexed_i32(&self, parameter: u32, index: u32) -> i32;
985
986 #[doc(alias = "glGetStringi")]
987 unsafe fn get_parameter_indexed_string(&self, parameter: u32, index: u32) -> String;
988
989 #[doc(alias = "glGetString")]
990 unsafe fn get_parameter_string(&self, parameter: u32) -> String;
991
992 unsafe fn get_parameter_buffer(&self, parameter: u32) -> Option<Self::Buffer>;
993
994 unsafe fn get_parameter_framebuffer(&self, parameter: u32) -> Option<Self::Framebuffer>;
995
996 unsafe fn get_parameter_program(&self, parameter: u32) -> Option<Self::Program>;
997
998 unsafe fn get_parameter_renderbuffer(&self, parameter: u32) -> Option<Self::Renderbuffer>;
999
1000 unsafe fn get_parameter_sampler(&self, parameter: u32) -> Option<Self::Sampler>;
1001
1002 unsafe fn get_parameter_texture(&self, parameter: u32) -> Option<Self::Texture>;
1003
1004 unsafe fn get_parameter_transform_feedback(
1005 &self,
1006 parameter: u32,
1007 ) -> Option<Self::TransformFeedback>;
1008
1009 unsafe fn get_parameter_vertex_array(&self, parameter: u32) -> Option<Self::VertexArray>;
1010
1011 unsafe fn get_renderbuffer_parameter_i32(&self, target: u32, parameter: u32) -> i32;
1012
1013 unsafe fn get_framebuffer_parameter_i32(&self, target: u32, parameter: u32) -> i32;
1014
1015 unsafe fn get_named_framebuffer_parameter_i32(
1016 &self,
1017 framebuffer: Option<Self::Framebuffer>,
1018 parameter: u32,
1019 ) -> i32;
1020
1021 unsafe fn get_framebuffer_attachment_parameter_i32(
1022 &self,
1023 target: u32,
1024 attachment: u32,
1025 parameter: u32,
1026 ) -> i32;
1027
1028 unsafe fn get_named_framebuffer_attachment_parameter_i32(
1029 &self,
1030 framebuffer: Option<Self::Framebuffer>,
1031 attachment: u32,
1032 parameter: u32,
1033 ) -> i32;
1034
1035 unsafe fn get_active_uniform_block_parameter_i32(
1036 &self,
1037 program: Self::Program,
1038 uniform_block_index: u32,
1039 parameter: u32,
1040 ) -> i32;
1041
1042 unsafe fn get_active_uniform_block_parameter_i32_slice(
1043 &self,
1044 program: Self::Program,
1045 uniform_block_index: u32,
1046 parameter: u32,
1047 out: &mut [i32],
1048 );
1049
1050 unsafe fn get_active_uniform_block_name(
1051 &self,
1052 program: Self::Program,
1053 uniform_block_index: u32,
1054 ) -> String;
1055
1056 unsafe fn get_uniform_location(
1057 &self,
1058 program: Self::Program,
1059 name: &str,
1060 ) -> Option<Self::UniformLocation>;
1061
1062 unsafe fn get_attrib_location(&self, program: Self::Program, name: &str) -> Option<u32>;
1063
1064 unsafe fn bind_attrib_location(&self, program: Self::Program, index: u32, name: &str);
1065
1066 unsafe fn get_active_attributes(&self, program: Self::Program) -> u32;
1067
1068 unsafe fn get_active_attribute(
1069 &self,
1070 program: Self::Program,
1071 index: u32,
1072 ) -> Option<ActiveAttribute>;
1073
1074 unsafe fn get_sync_status(&self, fence: Self::Fence) -> u32;
1075
1076 unsafe fn is_sync(&self, fence: Self::Fence) -> bool;
1077
1078 unsafe fn renderbuffer_storage(
1079 &self,
1080 target: u32,
1081 internal_format: u32,
1082 width: i32,
1083 height: i32,
1084 );
1085
1086 unsafe fn renderbuffer_storage_multisample(
1087 &self,
1088 target: u32,
1089 samples: i32,
1090 internal_format: u32,
1091 width: i32,
1092 height: i32,
1093 );
1094
1095 unsafe fn sampler_parameter_f32(&self, sampler: Self::Sampler, name: u32, value: f32);
1096
1097 unsafe fn sampler_parameter_f32_slice(&self, sampler: Self::Sampler, name: u32, value: &[f32]);
1098
1099 unsafe fn sampler_parameter_i32(&self, sampler: Self::Sampler, name: u32, value: i32);
1100
1101 unsafe fn get_sampler_parameter_i32(&self, sampler: Self::Sampler, name: u32) -> i32;
1102
1103 unsafe fn get_sampler_parameter_f32(&self, sampler: Self::Sampler, name: u32) -> f32;
1104
1105 unsafe fn generate_mipmap(&self, target: u32);
1106
1107 unsafe fn generate_texture_mipmap(&self, texture: Self::Texture);
1108
1109 unsafe fn tex_image_1d(
1110 &self,
1111 target: u32,
1112 level: i32,
1113 internal_format: i32,
1114 width: i32,
1115 border: i32,
1116 format: u32,
1117 ty: u32,
1118 pixels: PixelUnpackData,
1119 );
1120
1121 unsafe fn compressed_tex_image_1d(
1122 &self,
1123 target: u32,
1124 level: i32,
1125 internal_format: i32,
1126 width: i32,
1127 border: i32,
1128 image_size: i32,
1129 pixels: &[u8],
1130 );
1131
1132 unsafe fn tex_image_2d(
1133 &self,
1134 target: u32,
1135 level: i32,
1136 internal_format: i32,
1137 width: i32,
1138 height: i32,
1139 border: i32,
1140 format: u32,
1141 ty: u32,
1142 pixels: PixelUnpackData,
1143 );
1144
1145 unsafe fn tex_image_2d_multisample(
1146 &self,
1147 target: u32,
1148 samples: i32,
1149 internal_format: i32,
1150 width: i32,
1151 height: i32,
1152 fixed_sample_locations: bool,
1153 );
1154
1155 unsafe fn compressed_tex_image_2d(
1156 &self,
1157 target: u32,
1158 level: i32,
1159 internal_format: i32,
1160 width: i32,
1161 height: i32,
1162 border: i32,
1163 image_size: i32,
1164 pixels: &[u8],
1165 );
1166
1167 unsafe fn tex_image_3d(
1168 &self,
1169 target: u32,
1170 level: i32,
1171 internal_format: i32,
1172 width: i32,
1173 height: i32,
1174 depth: i32,
1175 border: i32,
1176 format: u32,
1177 ty: u32,
1178 pixels: PixelUnpackData,
1179 );
1180
1181 unsafe fn compressed_tex_image_3d(
1182 &self,
1183 target: u32,
1184 level: i32,
1185 internal_format: i32,
1186 width: i32,
1187 height: i32,
1188 depth: i32,
1189 border: i32,
1190 image_size: i32,
1191 pixels: &[u8],
1192 );
1193
1194 unsafe fn tex_storage_1d(&self, target: u32, levels: i32, internal_format: u32, width: i32);
1195
1196 unsafe fn tex_storage_2d(
1197 &self,
1198 target: u32,
1199 levels: i32,
1200 internal_format: u32,
1201 width: i32,
1202 height: i32,
1203 );
1204
1205 unsafe fn texture_storage_2d(
1206 &self,
1207 texture: Self::Texture,
1208 levels: i32,
1209 internal_format: u32,
1210 width: i32,
1211 height: i32,
1212 );
1213
1214 unsafe fn tex_storage_2d_multisample(
1215 &self,
1216 target: u32,
1217 samples: i32,
1218 internal_format: u32,
1219 width: i32,
1220 height: i32,
1221 fixed_sample_locations: bool,
1222 );
1223
1224 unsafe fn tex_storage_3d(
1225 &self,
1226 target: u32,
1227 levels: i32,
1228 internal_format: u32,
1229 width: i32,
1230 height: i32,
1231 depth: i32,
1232 );
1233
1234 unsafe fn texture_storage_3d(
1235 &self,
1236 texture: Self::Texture,
1237 levels: i32,
1238 internal_format: u32,
1239 width: i32,
1240 height: i32,
1241 depth: i32,
1242 );
1243
1244 unsafe fn get_uniform_i32(
1245 &self,
1246 program: Self::Program,
1247 location: &Self::UniformLocation,
1248 v: &mut [i32],
1249 );
1250
1251 unsafe fn get_uniform_u32(
1252 &self,
1253 program: Self::Program,
1254 location: &Self::UniformLocation,
1255 v: &mut [u32],
1256 );
1257
1258 unsafe fn get_uniform_f32(
1259 &self,
1260 program: Self::Program,
1261 location: &Self::UniformLocation,
1262 v: &mut [f32],
1263 );
1264
1265 unsafe fn uniform_1_i32(&self, location: Option<&Self::UniformLocation>, x: i32);
1266
1267 unsafe fn uniform_2_i32(&self, location: Option<&Self::UniformLocation>, x: i32, y: i32);
1268
1269 unsafe fn uniform_3_i32(
1270 &self,
1271 location: Option<&Self::UniformLocation>,
1272 x: i32,
1273 y: i32,
1274 z: i32,
1275 );
1276
1277 unsafe fn uniform_4_i32(
1278 &self,
1279 location: Option<&Self::UniformLocation>,
1280 x: i32,
1281 y: i32,
1282 z: i32,
1283 w: i32,
1284 );
1285
1286 unsafe fn uniform_1_i32_slice(&self, location: Option<&Self::UniformLocation>, v: &[i32]);
1287
1288 unsafe fn uniform_2_i32_slice(&self, location: Option<&Self::UniformLocation>, v: &[i32]);
1289
1290 unsafe fn uniform_3_i32_slice(&self, location: Option<&Self::UniformLocation>, v: &[i32]);
1291
1292 unsafe fn uniform_4_i32_slice(&self, location: Option<&Self::UniformLocation>, v: &[i32]);
1293
1294 unsafe fn uniform_1_u32(&self, location: Option<&Self::UniformLocation>, x: u32);
1295
1296 unsafe fn uniform_2_u32(&self, location: Option<&Self::UniformLocation>, x: u32, y: u32);
1297
1298 unsafe fn uniform_3_u32(
1299 &self,
1300 location: Option<&Self::UniformLocation>,
1301 x: u32,
1302 y: u32,
1303 z: u32,
1304 );
1305
1306 unsafe fn uniform_4_u32(
1307 &self,
1308 location: Option<&Self::UniformLocation>,
1309 x: u32,
1310 y: u32,
1311 z: u32,
1312 w: u32,
1313 );
1314
1315 unsafe fn uniform_1_u32_slice(&self, location: Option<&Self::UniformLocation>, v: &[u32]);
1316
1317 unsafe fn uniform_2_u32_slice(&self, location: Option<&Self::UniformLocation>, v: &[u32]);
1318
1319 unsafe fn uniform_3_u32_slice(&self, location: Option<&Self::UniformLocation>, v: &[u32]);
1320
1321 unsafe fn uniform_4_u32_slice(&self, location: Option<&Self::UniformLocation>, v: &[u32]);
1322
1323 unsafe fn uniform_1_f32(&self, location: Option<&Self::UniformLocation>, x: f32);
1324
1325 unsafe fn uniform_2_f32(&self, location: Option<&Self::UniformLocation>, x: f32, y: f32);
1326
1327 unsafe fn uniform_3_f32(
1328 &self,
1329 location: Option<&Self::UniformLocation>,
1330 x: f32,
1331 y: f32,
1332 z: f32,
1333 );
1334
1335 unsafe fn uniform_4_f32(
1336 &self,
1337 location: Option<&Self::UniformLocation>,
1338 x: f32,
1339 y: f32,
1340 z: f32,
1341 w: f32,
1342 );
1343
1344 unsafe fn uniform_1_f32_slice(&self, location: Option<&Self::UniformLocation>, v: &[f32]);
1345
1346 unsafe fn uniform_2_f32_slice(&self, location: Option<&Self::UniformLocation>, v: &[f32]);
1347
1348 unsafe fn uniform_3_f32_slice(&self, location: Option<&Self::UniformLocation>, v: &[f32]);
1349
1350 unsafe fn uniform_4_f32_slice(&self, location: Option<&Self::UniformLocation>, v: &[f32]);
1351
1352 unsafe fn uniform_matrix_2_f32_slice(
1353 &self,
1354 location: Option<&Self::UniformLocation>,
1355 transpose: bool,
1356 v: &[f32],
1357 );
1358
1359 unsafe fn uniform_matrix_2x3_f32_slice(
1360 &self,
1361 location: Option<&Self::UniformLocation>,
1362 transpose: bool,
1363 v: &[f32],
1364 );
1365
1366 unsafe fn uniform_matrix_2x4_f32_slice(
1367 &self,
1368 location: Option<&Self::UniformLocation>,
1369 transpose: bool,
1370 v: &[f32],
1371 );
1372
1373 unsafe fn uniform_matrix_3x2_f32_slice(
1374 &self,
1375 location: Option<&Self::UniformLocation>,
1376 transpose: bool,
1377 v: &[f32],
1378 );
1379
1380 unsafe fn uniform_matrix_3_f32_slice(
1381 &self,
1382 location: Option<&Self::UniformLocation>,
1383 transpose: bool,
1384 v: &[f32],
1385 );
1386
1387 unsafe fn uniform_matrix_3x4_f32_slice(
1388 &self,
1389 location: Option<&Self::UniformLocation>,
1390 transpose: bool,
1391 v: &[f32],
1392 );
1393
1394 unsafe fn uniform_matrix_4x2_f32_slice(
1395 &self,
1396 location: Option<&Self::UniformLocation>,
1397 transpose: bool,
1398 v: &[f32],
1399 );
1400
1401 unsafe fn uniform_matrix_4x3_f32_slice(
1402 &self,
1403 location: Option<&Self::UniformLocation>,
1404 transpose: bool,
1405 v: &[f32],
1406 );
1407
1408 unsafe fn uniform_matrix_4_f32_slice(
1409 &self,
1410 location: Option<&Self::UniformLocation>,
1411 transpose: bool,
1412 v: &[f32],
1413 );
1414
1415 unsafe fn unmap_buffer(&self, target: u32);
1416
1417 unsafe fn cull_face(&self, value: u32);
1418
1419 unsafe fn color_mask(&self, red: bool, green: bool, blue: bool, alpha: bool);
1420
1421 unsafe fn color_mask_draw_buffer(
1422 &self,
1423 buffer: u32,
1424 red: bool,
1425 green: bool,
1426 blue: bool,
1427 alpha: bool,
1428 );
1429
1430 unsafe fn depth_mask(&self, value: bool);
1431
1432 unsafe fn blend_color(&self, red: f32, green: f32, blue: f32, alpha: f32);
1433
1434 unsafe fn line_width(&self, width: f32);
1435
1436 unsafe fn map_buffer_range(
1437 &self,
1438 target: u32,
1439 offset: i32,
1440 length: i32,
1441 access: u32,
1442 ) -> *mut u8;
1443
1444 unsafe fn flush_mapped_buffer_range(&self, target: u32, offset: i32, length: i32);
1445
1446 unsafe fn invalidate_buffer_sub_data(&self, target: u32, offset: i32, length: i32);
1447
1448 unsafe fn invalidate_framebuffer(&self, target: u32, attachments: &[u32]);
1449
1450 unsafe fn invalidate_sub_framebuffer(
1451 &self,
1452 target: u32,
1453 attachments: &[u32],
1454 x: i32,
1455 y: i32,
1456 width: i32,
1457 height: i32,
1458 );
1459
1460 unsafe fn polygon_offset(&self, factor: f32, units: f32);
1461
1462 unsafe fn polygon_mode(&self, face: u32, mode: u32);
1463
1464 unsafe fn finish(&self);
1465
1466 unsafe fn bind_texture(&self, target: u32, texture: Option<Self::Texture>);
1467
1468 unsafe fn bind_texture_unit(&self, unit: u32, texture: Option<Self::Texture>);
1469
1470 unsafe fn bind_sampler(&self, unit: u32, sampler: Option<Self::Sampler>);
1471
1472 unsafe fn active_texture(&self, unit: u32);
1473
1474 unsafe fn fence_sync(&self, condition: u32, flags: u32) -> Result<Self::Fence, String>;
1475
1476 unsafe fn tex_parameter_f32(&self, target: u32, parameter: u32, value: f32);
1477
1478 unsafe fn tex_parameter_i32(&self, target: u32, parameter: u32, value: i32);
1479
1480 unsafe fn texture_parameter_i32(&self, texture: Self::Texture, parameter: u32, value: i32);
1481
1482 unsafe fn tex_parameter_f32_slice(&self, target: u32, parameter: u32, values: &[f32]);
1483
1484 unsafe fn tex_parameter_i32_slice(&self, target: u32, parameter: u32, values: &[i32]);
1485
1486 unsafe fn tex_sub_image_2d(
1487 &self,
1488 target: u32,
1489 level: i32,
1490 x_offset: i32,
1491 y_offset: i32,
1492 width: i32,
1493 height: i32,
1494 format: u32,
1495 ty: u32,
1496 pixels: PixelUnpackData,
1497 );
1498
1499 unsafe fn texture_sub_image_2d(
1500 &self,
1501 texture: Self::Texture,
1502 level: i32,
1503 x_offset: i32,
1504 y_offset: i32,
1505 width: i32,
1506 height: i32,
1507 format: u32,
1508 ty: u32,
1509 pixels: PixelUnpackData,
1510 );
1511
1512 unsafe fn compressed_tex_sub_image_2d(
1513 &self,
1514 target: u32,
1515 level: i32,
1516 x_offset: i32,
1517 y_offset: i32,
1518 width: i32,
1519 height: i32,
1520 format: u32,
1521 pixels: CompressedPixelUnpackData,
1522 );
1523
1524 unsafe fn tex_sub_image_3d(
1525 &self,
1526 target: u32,
1527 level: i32,
1528 x_offset: i32,
1529 y_offset: i32,
1530 z_offset: i32,
1531 width: i32,
1532 height: i32,
1533 depth: i32,
1534 format: u32,
1535 ty: u32,
1536 pixels: PixelUnpackData,
1537 );
1538
1539 unsafe fn texture_sub_image_3d(
1540 &self,
1541 texture: Self::Texture,
1542 level: i32,
1543 x_offset: i32,
1544 y_offset: i32,
1545 z_offset: i32,
1546 width: i32,
1547 height: i32,
1548 depth: i32,
1549 format: u32,
1550 ty: u32,
1551 pixels: PixelUnpackData,
1552 );
1553
1554 unsafe fn compressed_tex_sub_image_3d(
1555 &self,
1556 target: u32,
1557 level: i32,
1558 x_offset: i32,
1559 y_offset: i32,
1560 z_offset: i32,
1561 width: i32,
1562 height: i32,
1563 depth: i32,
1564 format: u32,
1565 pixels: CompressedPixelUnpackData,
1566 );
1567
1568 unsafe fn depth_func(&self, func: u32);
1569
1570 unsafe fn depth_range_f32(&self, near: f32, far: f32);
1571
1572 unsafe fn depth_range_f64(&self, near: f64, far: f64);
1573
1574 unsafe fn depth_range(&self, near: f64, far: f64);
1575
1576 unsafe fn depth_range_f64_slice(&self, first: u32, count: i32, values: &[[f64; 2]]);
1577
1578 unsafe fn scissor(&self, x: i32, y: i32, width: i32, height: i32);
1579
1580 unsafe fn scissor_slice(&self, first: u32, count: i32, scissors: &[[i32; 4]]);
1581
1582 unsafe fn vertex_array_attrib_binding_f32(
1583 &self,
1584 vao: Self::VertexArray,
1585 index: u32,
1586 binding_index: u32,
1587 );
1588
1589 unsafe fn vertex_array_attrib_format_f32(
1590 &self,
1591 vao: Self::VertexArray,
1592 index: u32,
1593 size: i32,
1594 data_type: u32,
1595 normalized: bool,
1596 relative_offset: u32,
1597 );
1598
1599 unsafe fn vertex_array_attrib_format_i32(
1600 &self,
1601 vao: Self::VertexArray,
1602 index: u32,
1603 size: i32,
1604 data_type: u32,
1605 relative_offset: u32,
1606 );
1607
1608 unsafe fn vertex_array_attrib_format_f64(
1609 &self,
1610 vao: Self::VertexArray,
1611 index: u32,
1612 size: i32,
1613 data_type: u32,
1614 relative_offset: u32,
1615 );
1616
1617 unsafe fn vertex_array_element_buffer(
1618 &self,
1619 vao: Self::VertexArray,
1620 buffer: Option<Self::Buffer>,
1621 );
1622
1623 unsafe fn vertex_array_vertex_buffer(
1624 &self,
1625 vao: Self::VertexArray,
1626 binding_index: u32,
1627 buffer: Option<Self::Buffer>,
1628 offset: i32,
1629 stride: i32,
1630 );
1631
1632 unsafe fn vertex_attrib_divisor(&self, index: u32, divisor: u32);
1633
1634 unsafe fn get_vertex_attrib_parameter_f32_slice(
1635 &self,
1636 index: u32,
1637 pname: u32,
1638 result: &mut [f32],
1639 );
1640
1641 unsafe fn vertex_attrib_pointer_f32(
1642 &self,
1643 index: u32,
1644 size: i32,
1645 data_type: u32,
1646 normalized: bool,
1647 stride: i32,
1648 offset: i32,
1649 );
1650
1651 unsafe fn vertex_attrib_pointer_i32(
1652 &self,
1653 index: u32,
1654 size: i32,
1655 data_type: u32,
1656 stride: i32,
1657 offset: i32,
1658 );
1659
1660 unsafe fn vertex_attrib_pointer_f64(
1661 &self,
1662 index: u32,
1663 size: i32,
1664 data_type: u32,
1665 stride: i32,
1666 offset: i32,
1667 );
1668
1669 unsafe fn vertex_attrib_format_f32(
1670 &self,
1671 index: u32,
1672 size: i32,
1673 data_type: u32,
1674 normalized: bool,
1675 relative_offset: u32,
1676 );
1677
1678 unsafe fn vertex_attrib_format_i32(
1679 &self,
1680 index: u32,
1681 size: i32,
1682 data_type: u32,
1683 relative_offset: u32,
1684 );
1685
1686 unsafe fn vertex_attrib_format_f64(
1687 &self,
1688 index: u32,
1689 size: i32,
1690 data_type: u32,
1691 relative_offset: u32,
1692 );
1693
1694 unsafe fn vertex_attrib_1_f32(&self, index: u32, x: f32);
1695
1696 unsafe fn vertex_attrib_2_f32(&self, index: u32, x: f32, y: f32);
1697
1698 unsafe fn vertex_attrib_3_f32(&self, index: u32, x: f32, y: f32, z: f32);
1699
1700 unsafe fn vertex_attrib_4_f32(&self, index: u32, x: f32, y: f32, z: f32, w: f32);
1701
1702 unsafe fn vertex_attrib_4_i32(&self, index: u32, x: i32, y: i32, z: i32, w: i32);
1703
1704 unsafe fn vertex_attrib_4_u32(&self, index: u32, x: u32, y: u32, z: u32, w: u32);
1705
1706 unsafe fn vertex_attrib_1_f32_slice(&self, index: u32, v: &[f32]);
1707
1708 unsafe fn vertex_attrib_2_f32_slice(&self, index: u32, v: &[f32]);
1709
1710 unsafe fn vertex_attrib_3_f32_slice(&self, index: u32, v: &[f32]);
1711
1712 unsafe fn vertex_attrib_4_f32_slice(&self, index: u32, v: &[f32]);
1713
1714 unsafe fn vertex_attrib_binding(&self, attrib_index: u32, binding_index: u32);
1715
1716 unsafe fn vertex_binding_divisor(&self, binding_index: u32, divisor: u32);
1717
1718 unsafe fn viewport(&self, x: i32, y: i32, width: i32, height: i32);
1719
1720 unsafe fn viewport_f32_slice(&self, first: u32, count: i32, values: &[[f32; 4]]);
1721
1722 unsafe fn blend_equation(&self, mode: u32);
1723
1724 unsafe fn blend_equation_draw_buffer(&self, draw_buffer: u32, mode: u32);
1725
1726 unsafe fn blend_equation_separate(&self, mode_rgb: u32, mode_alpha: u32);
1727
1728 unsafe fn blend_equation_separate_draw_buffer(
1729 &self,
1730 buffer: u32,
1731 mode_rgb: u32,
1732 mode_alpha: u32,
1733 );
1734
1735 unsafe fn blend_func(&self, src: u32, dst: u32);
1736
1737 unsafe fn blend_func_draw_buffer(&self, draw_buffer: u32, src: u32, dst: u32);
1738
1739 unsafe fn blend_func_separate(
1740 &self,
1741 src_rgb: u32,
1742 dst_rgb: u32,
1743 src_alpha: u32,
1744 dst_alpha: u32,
1745 );
1746
1747 unsafe fn blend_func_separate_draw_buffer(
1748 &self,
1749 draw_buffer: u32,
1750 src_rgb: u32,
1751 dst_rgb: u32,
1752 src_alpha: u32,
1753 dst_alpha: u32,
1754 );
1755
1756 unsafe fn stencil_func(&self, func: u32, reference: i32, mask: u32);
1757
1758 unsafe fn stencil_func_separate(&self, face: u32, func: u32, reference: i32, mask: u32);
1759
1760 unsafe fn stencil_mask(&self, mask: u32);
1761
1762 unsafe fn stencil_mask_separate(&self, face: u32, mask: u32);
1763
1764 unsafe fn stencil_op(&self, stencil_fail: u32, depth_fail: u32, pass: u32);
1765
1766 unsafe fn stencil_op_separate(&self, face: u32, stencil_fail: u32, depth_fail: u32, pass: u32);
1767
1768 unsafe fn debug_message_control(
1769 &self,
1770 source: u32,
1771 msg_type: u32,
1772 severity: u32,
1773 ids: &[u32],
1774 enabled: bool,
1775 );
1776
1777 unsafe fn debug_message_insert<S>(
1778 &self,
1779 source: u32,
1780 msg_type: u32,
1781 id: u32,
1782 severity: u32,
1783 msg: S,
1784 ) where
1785 S: AsRef<str>;
1786
1787 unsafe fn debug_message_callback<F>(&mut self, callback: F)
1788 where
1789 F: Fn(u32, u32, u32, u32, &str) + Send + Sync + 'static;
1790
1791 unsafe fn get_debug_message_log(&self, count: u32) -> Vec<DebugMessageLogEntry>;
1792
1793 unsafe fn push_debug_group<S>(&self, source: u32, id: u32, message: S)
1794 where
1795 S: AsRef<str>;
1796
1797 unsafe fn pop_debug_group(&self);
1798
1799 unsafe fn object_label<S>(&self, identifier: u32, name: u32, label: Option<S>)
1800 where
1801 S: AsRef<str>;
1802
1803 unsafe fn get_object_label(&self, identifier: u32, name: u32) -> String;
1804
1805 unsafe fn object_ptr_label<S>(&self, sync: Self::Fence, label: Option<S>)
1806 where
1807 S: AsRef<str>;
1808
1809 unsafe fn get_object_ptr_label(&self, sync: Self::Fence) -> String;
1810
1811 unsafe fn get_uniform_block_index(&self, program: Self::Program, name: &str) -> Option<u32>;
1812
1813 unsafe fn get_uniform_indices(
1814 &self,
1815 program: Self::Program,
1816 names: &[&str],
1817 ) -> Vec<Option<u32>>;
1818
1819 unsafe fn uniform_block_binding(&self, program: Self::Program, index: u32, binding: u32);
1820
1821 unsafe fn get_shader_storage_block_index(
1822 &self,
1823 program: Self::Program,
1824 name: &str,
1825 ) -> Option<u32>;
1826
1827 unsafe fn shader_storage_block_binding(&self, program: Self::Program, index: u32, binding: u32);
1828
1829 unsafe fn read_buffer(&self, src: u32);
1830
1831 unsafe fn named_framebuffer_read_buffer(
1832 &self,
1833 framebuffer: Option<Self::Framebuffer>,
1834 src: u32,
1835 );
1836
1837 unsafe fn read_pixels(
1838 &self,
1839 x: i32,
1840 y: i32,
1841 width: i32,
1842 height: i32,
1843 format: u32,
1844 gltype: u32,
1845 pixels: PixelPackData,
1846 );
1847
1848 unsafe fn begin_query(&self, target: u32, query: Self::Query);
1849
1850 unsafe fn end_query(&self, target: u32);
1851
1852 unsafe fn query_counter(&self, query: Self::Query, target: u32);
1853
1854 unsafe fn get_query_parameter_u32(&self, query: Self::Query, parameter: u32) -> u32;
1855
1856 unsafe fn get_query_parameter_u64_with_offset(
1857 &self,
1858 query: Self::Query,
1859 parameter: u32,
1860 offset: usize,
1861 );
1862
1863 unsafe fn delete_transform_feedback(&self, transform_feedback: Self::TransformFeedback);
1864
1865 unsafe fn is_transform_feedback(&self, transform_feedback: Self::TransformFeedback) -> bool;
1866
1867 unsafe fn create_transform_feedback(&self) -> Result<Self::TransformFeedback, String>;
1868
1869 unsafe fn bind_transform_feedback(
1870 &self,
1871 target: u32,
1872 transform_feedback: Option<Self::TransformFeedback>,
1873 );
1874
1875 unsafe fn begin_transform_feedback(&self, primitive_mode: u32);
1876
1877 unsafe fn end_transform_feedback(&self);
1878
1879 unsafe fn pause_transform_feedback(&self);
1880
1881 unsafe fn resume_transform_feedback(&self);
1882
1883 unsafe fn transform_feedback_varyings(
1884 &self,
1885 program: Self::Program,
1886 varyings: &[&str],
1887 buffer_mode: u32,
1888 );
1889
1890 unsafe fn get_transform_feedback_varying(
1891 &self,
1892 program: Self::Program,
1893 index: u32,
1894 ) -> Option<ActiveTransformFeedback>;
1895
1896 unsafe fn memory_barrier(&self, barriers: u32);
1897
1898 unsafe fn memory_barrier_by_region(&self, barriers: u32);
1899
1900 unsafe fn bind_image_texture(
1901 &self,
1902 unit: u32,
1903 texture: Option<Self::Texture>,
1904 level: i32,
1905 layered: bool,
1906 layer: i32,
1907 access: u32,
1908 format: u32,
1909 );
1910
1911 unsafe fn max_shader_compiler_threads(&self, count: u32);
1912
1913 unsafe fn hint(&self, target: u32, mode: u32);
1914
1915 unsafe fn sample_coverage(&self, value: f32, invert: bool);
1916
1917 unsafe fn get_internal_format_i32_slice(
1918 &self,
1919 target: u32,
1920 internal_format: u32,
1921 pname: u32,
1922 result: &mut [i32],
1923 );
1924}
1925
1926/// Returns number of components used by format
1927pub fn components_per_format(format: u32) -> usize {
1928 match format {
1929 RED | GREEN | BLUE => 1,
1930 RED_INTEGER | GREEN_INTEGER | BLUE_INTEGER => 1,
1931 ALPHA | LUMINANCE | DEPTH_COMPONENT => 1,
1932 RG | LUMINANCE_ALPHA => 2,
1933 RGB | BGR => 3,
1934 RGBA | BGRA => 4,
1935 _ => panic!("unsupported format: {:?}", format),
1936 }
1937}
1938
1939/// Returns number of bytes used by pixel type (in one component)
1940pub fn bytes_per_type(pixel_type: u32) -> usize {
1941 // per https://www.khronos.org/opengl/wiki/Pixel_Transfer#Pixel_type
1942 match pixel_type {
1943 BYTE | UNSIGNED_BYTE => 1,
1944 SHORT | UNSIGNED_SHORT => 2,
1945 INT | UNSIGNED_INT => 4,
1946 HALF_FLOAT | HALF_FLOAT_OES => 2,
1947 FLOAT => 4,
1948 _ => panic!("unsupported pixel type: {:?}", pixel_type),
1949 }
1950}
1951
1952pub fn compute_size(width: i32, height: i32, format: u32, pixel_type: u32) -> usize {
1953 width as usize * height as usize * components_per_format(format) * bytes_per_type(pixel_type)
1954}
1955
1956pub const ACTIVE_ATOMIC_COUNTER_BUFFERS: u32 = 0x92D9;
1957
1958pub const ACTIVE_ATTRIBUTES: u32 = 0x8B89;
1959
1960pub const ACTIVE_ATTRIBUTE_MAX_LENGTH: u32 = 0x8B8A;
1961
1962pub const ACTIVE_PROGRAM: u32 = 0x8259;
1963
1964pub const ACTIVE_RESOURCES: u32 = 0x92F5;
1965
1966pub const ACTIVE_SUBROUTINES: u32 = 0x8DE5;
1967
1968pub const ACTIVE_SUBROUTINE_MAX_LENGTH: u32 = 0x8E48;
1969
1970pub const ACTIVE_SUBROUTINE_UNIFORMS: u32 = 0x8DE6;
1971
1972pub const ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS: u32 = 0x8E47;
1973
1974pub const ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH: u32 = 0x8E49;
1975
1976pub const ACTIVE_TEXTURE: u32 = 0x84E0;
1977
1978pub const ACTIVE_UNIFORMS: u32 = 0x8B86;
1979
1980pub const ACTIVE_UNIFORM_BLOCKS: u32 = 0x8A36;
1981
1982pub const ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: u32 = 0x8A35;
1983
1984pub const ACTIVE_UNIFORM_MAX_LENGTH: u32 = 0x8B87;
1985
1986pub const ACTIVE_VARIABLES: u32 = 0x9305;
1987
1988pub const ALIASED_LINE_WIDTH_RANGE: u32 = 0x846E;
1989
1990pub const ALIASED_POINT_SIZE_RANGE: u32 = 0x846D;
1991
1992pub const ALL_BARRIER_BITS: u32 = 0xFFFFFFFF;
1993
1994pub const ALL_SHADER_BITS: u32 = 0xFFFFFFFF;
1995
1996pub const ALPHA: u32 = 0x1906;
1997
1998pub const ALPHA_BITS: u32 = 0x0D55;
1999
2000pub const ALREADY_SIGNALED: u32 = 0x911A;
2001
2002pub const ALWAYS: u32 = 0x0207;
2003
2004pub const AND: u32 = 0x1501;
2005
2006pub const AND_INVERTED: u32 = 0x1504;
2007
2008pub const AND_REVERSE: u32 = 0x1502;
2009
2010pub const ANY_SAMPLES_PASSED: u32 = 0x8C2F;
2011
2012pub const ANY_SAMPLES_PASSED_CONSERVATIVE: u32 = 0x8D6A;
2013
2014pub const ARRAY_BUFFER: u32 = 0x8892;
2015
2016pub const ARRAY_BUFFER_BINDING: u32 = 0x8894;
2017
2018pub const ARRAY_SIZE: u32 = 0x92FB;
2019
2020pub const ARRAY_STRIDE: u32 = 0x92FE;
2021
2022pub const ATOMIC_COUNTER_BARRIER_BIT: u32 = 0x00001000;
2023
2024pub const ATOMIC_COUNTER_BUFFER: u32 = 0x92C0;
2025
2026pub const ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS: u32 = 0x92C5;
2027
2028pub const ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES: u32 = 0x92C6;
2029
2030pub const ATOMIC_COUNTER_BUFFER_BINDING: u32 = 0x92C1;
2031
2032pub const ATOMIC_COUNTER_BUFFER_DATA_SIZE: u32 = 0x92C4;
2033
2034pub const ATOMIC_COUNTER_BUFFER_INDEX: u32 = 0x9301;
2035
2036pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER: u32 = 0x90ED;
2037
2038pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER: u32 = 0x92CB;
2039
2040pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER: u32 = 0x92CA;
2041
2042pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER: u32 = 0x92C8;
2043
2044pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER: u32 = 0x92C9;
2045
2046pub const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER: u32 = 0x92C7;
2047
2048pub const ATOMIC_COUNTER_BUFFER_SIZE: u32 = 0x92C3;
2049
2050pub const ATOMIC_COUNTER_BUFFER_START: u32 = 0x92C2;
2051
2052pub const ATTACHED_SHADERS: u32 = 0x8B85;
2053
2054pub const AUTO_GENERATE_MIPMAP: u32 = 0x8295;
2055
2056pub const BACK: u32 = 0x0405;
2057
2058pub const BACK_LEFT: u32 = 0x0402;
2059
2060pub const BACK_RIGHT: u32 = 0x0403;
2061
2062pub const BGR: u32 = 0x80E0;
2063
2064pub const BGRA: u32 = 0x80E1;
2065
2066pub const BGRA_INTEGER: u32 = 0x8D9B;
2067
2068pub const BGR_INTEGER: u32 = 0x8D9A;
2069
2070pub const BLEND: u32 = 0x0BE2;
2071
2072pub const BLEND_COLOR: u32 = 0x8005;
2073
2074pub const BLEND_DST: u32 = 0x0BE0;
2075
2076pub const BLEND_DST_ALPHA: u32 = 0x80CA;
2077
2078pub const BLEND_DST_RGB: u32 = 0x80C8;
2079
2080pub const BLEND_EQUATION: u32 = 0x8009;
2081
2082pub const BLEND_EQUATION_ALPHA: u32 = 0x883D;
2083
2084pub const BLEND_EQUATION_RGB: u32 = 0x8009;
2085
2086pub const BLEND_SRC: u32 = 0x0BE1;
2087
2088pub const BLEND_SRC_ALPHA: u32 = 0x80CB;
2089
2090pub const BLEND_SRC_RGB: u32 = 0x80C9;
2091
2092pub const BLOCK_INDEX: u32 = 0x92FD;
2093
2094pub const BLUE: u32 = 0x1905;
2095
2096pub const BLUE_BITS: u32 = 0x0D54;
2097
2098pub const BLUE_INTEGER: u32 = 0x8D96;
2099
2100pub const BOOL: u32 = 0x8B56;
2101
2102pub const BOOL_VEC2: u32 = 0x8B57;
2103
2104pub const BOOL_VEC3: u32 = 0x8B58;
2105
2106pub const BOOL_VEC4: u32 = 0x8B59;
2107
2108pub const BUFFER: u32 = 0x82E0;
2109
2110pub const BUFFER_ACCESS: u32 = 0x88BB;
2111
2112pub const BUFFER_ACCESS_FLAGS: u32 = 0x911F;
2113
2114pub const BUFFER_BINDING: u32 = 0x9302;
2115
2116pub const BUFFER_DATA_SIZE: u32 = 0x9303;
2117
2118pub const BUFFER_IMMUTABLE_STORAGE: u32 = 0x821F;
2119
2120pub const BUFFER_MAPPED: u32 = 0x88BC;
2121
2122pub const BUFFER_MAP_LENGTH: u32 = 0x9120;
2123
2124pub const BUFFER_MAP_OFFSET: u32 = 0x9121;
2125
2126pub const BUFFER_MAP_POINTER: u32 = 0x88BD;
2127
2128pub const BUFFER_SIZE: u32 = 0x8764;
2129
2130pub const BUFFER_STORAGE_FLAGS: u32 = 0x8220;
2131
2132pub const BUFFER_UPDATE_BARRIER_BIT: u32 = 0x00000200;
2133
2134pub const BUFFER_USAGE: u32 = 0x8765;
2135
2136pub const BUFFER_VARIABLE: u32 = 0x92E5;
2137
2138pub const BYTE: u32 = 0x1400;
2139
2140pub const CAVEAT_SUPPORT: u32 = 0x82B8;
2141
2142pub const CCW: u32 = 0x0901;
2143
2144pub const CLAMP_READ_COLOR: u32 = 0x891C;
2145
2146pub const CLAMP_TO_BORDER: u32 = 0x812D;
2147
2148pub const CLAMP_TO_EDGE: u32 = 0x812F;
2149
2150pub const CLEAR: u32 = 0x1500;
2151
2152pub const CLEAR_BUFFER: u32 = 0x82B4;
2153
2154pub const CLEAR_TEXTURE: u32 = 0x9365;
2155
2156pub const CLIENT_MAPPED_BUFFER_BARRIER_BIT: u32 = 0x00004000;
2157
2158pub const CLIENT_STORAGE_BIT: u32 = 0x0200;
2159
2160pub const CLIPPING_INPUT_PRIMITIVES: u32 = 0x82F6;
2161
2162pub const CLIPPING_OUTPUT_PRIMITIVES: u32 = 0x82F7;
2163
2164pub const CLIP_DEPTH_MODE: u32 = 0x935D;
2165
2166pub const CLIP_DISTANCE0: u32 = 0x3000;
2167
2168pub const CLIP_DISTANCE1: u32 = 0x3001;
2169
2170pub const CLIP_DISTANCE2: u32 = 0x3002;
2171
2172pub const CLIP_DISTANCE3: u32 = 0x3003;
2173
2174pub const CLIP_DISTANCE4: u32 = 0x3004;
2175
2176pub const CLIP_DISTANCE5: u32 = 0x3005;
2177
2178pub const CLIP_DISTANCE6: u32 = 0x3006;
2179
2180pub const CLIP_DISTANCE7: u32 = 0x3007;
2181
2182pub const CLIP_ORIGIN: u32 = 0x935C;
2183
2184pub const COLOR: u32 = 0x1800;
2185
2186pub const COLOR_ATTACHMENT0: u32 = 0x8CE0;
2187
2188pub const COLOR_ATTACHMENT1: u32 = 0x8CE1;
2189
2190pub const COLOR_ATTACHMENT10: u32 = 0x8CEA;
2191
2192pub const COLOR_ATTACHMENT11: u32 = 0x8CEB;
2193
2194pub const COLOR_ATTACHMENT12: u32 = 0x8CEC;
2195
2196pub const COLOR_ATTACHMENT13: u32 = 0x8CED;
2197
2198pub const COLOR_ATTACHMENT14: u32 = 0x8CEE;
2199
2200pub const COLOR_ATTACHMENT15: u32 = 0x8CEF;
2201
2202pub const COLOR_ATTACHMENT16: u32 = 0x8CF0;
2203
2204pub const COLOR_ATTACHMENT17: u32 = 0x8CF1;
2205
2206pub const COLOR_ATTACHMENT18: u32 = 0x8CF2;
2207
2208pub const COLOR_ATTACHMENT19: u32 = 0x8CF3;
2209
2210pub const COLOR_ATTACHMENT2: u32 = 0x8CE2;
2211
2212pub const COLOR_ATTACHMENT20: u32 = 0x8CF4;
2213
2214pub const COLOR_ATTACHMENT21: u32 = 0x8CF5;
2215
2216pub const COLOR_ATTACHMENT22: u32 = 0x8CF6;
2217
2218pub const COLOR_ATTACHMENT23: u32 = 0x8CF7;
2219
2220pub const COLOR_ATTACHMENT24: u32 = 0x8CF8;
2221
2222pub const COLOR_ATTACHMENT25: u32 = 0x8CF9;
2223
2224pub const COLOR_ATTACHMENT26: u32 = 0x8CFA;
2225
2226pub const COLOR_ATTACHMENT27: u32 = 0x8CFB;
2227
2228pub const COLOR_ATTACHMENT28: u32 = 0x8CFC;
2229
2230pub const COLOR_ATTACHMENT29: u32 = 0x8CFD;
2231
2232pub const COLOR_ATTACHMENT3: u32 = 0x8CE3;
2233
2234pub const COLOR_ATTACHMENT30: u32 = 0x8CFE;
2235
2236pub const COLOR_ATTACHMENT31: u32 = 0x8CFF;
2237
2238pub const COLOR_ATTACHMENT4: u32 = 0x8CE4;
2239
2240pub const COLOR_ATTACHMENT5: u32 = 0x8CE5;
2241
2242pub const COLOR_ATTACHMENT6: u32 = 0x8CE6;
2243
2244pub const COLOR_ATTACHMENT7: u32 = 0x8CE7;
2245
2246pub const COLOR_ATTACHMENT8: u32 = 0x8CE8;
2247
2248pub const COLOR_ATTACHMENT9: u32 = 0x8CE9;
2249
2250pub const COLOR_BUFFER_BIT: u32 = 0x00004000;
2251
2252pub const COLOR_CLEAR_VALUE: u32 = 0x0C22;
2253
2254pub const COLOR_COMPONENTS: u32 = 0x8283;
2255
2256pub const COLOR_ENCODING: u32 = 0x8296;
2257
2258pub const COLOR_LOGIC_OP: u32 = 0x0BF2;
2259
2260pub const COLOR_RENDERABLE: u32 = 0x8286;
2261
2262pub const COLOR_WRITEMASK: u32 = 0x0C23;
2263
2264pub const COMMAND_BARRIER_BIT: u32 = 0x00000040;
2265
2266pub const COMPARE_REF_TO_TEXTURE: u32 = 0x884E;
2267
2268pub const COMPATIBLE_SUBROUTINES: u32 = 0x8E4B;
2269
2270pub const COMPILE_STATUS: u32 = 0x8B81;
2271
2272pub const COMPLETION_STATUS: u32 = 0x91B1;
2273
2274pub const COMPRESSED_R11_EAC: u32 = 0x9270;
2275
2276pub const COMPRESSED_RED: u32 = 0x8225;
2277
2278pub const COMPRESSED_RED_RGTC1: u32 = 0x8DBB;
2279
2280pub const COMPRESSED_RG: u32 = 0x8226;
2281
2282pub const COMPRESSED_RG11_EAC: u32 = 0x9272;
2283
2284pub const COMPRESSED_RGB: u32 = 0x84ED;
2285
2286pub const COMPRESSED_RGB8_ETC2: u32 = 0x9274;
2287
2288pub const COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: u32 = 0x9276;
2289
2290pub const COMPRESSED_RGBA: u32 = 0x84EE;
2291
2292pub const COMPRESSED_RGBA8_ETC2_EAC: u32 = 0x9278;
2293
2294pub const COMPRESSED_RGBA_BPTC_UNORM: u32 = 0x8E8C;
2295
2296pub const COMPRESSED_RGB_BPTC_SIGNED_FLOAT: u32 = 0x8E8E;
2297
2298pub const COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT: u32 = 0x8E8F;
2299
2300pub const COMPRESSED_RG_RGTC2: u32 = 0x8DBD;
2301
2302pub const COMPRESSED_SIGNED_R11_EAC: u32 = 0x9271;
2303
2304pub const COMPRESSED_SIGNED_RED_RGTC1: u32 = 0x8DBC;
2305
2306pub const COMPRESSED_SIGNED_RG11_EAC: u32 = 0x9273;
2307
2308pub const COMPRESSED_SIGNED_RG_RGTC2: u32 = 0x8DBE;
2309
2310pub const COMPRESSED_SRGB: u32 = 0x8C48;
2311
2312pub const COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: u32 = 0x9279;
2313
2314pub const COMPRESSED_SRGB8_ETC2: u32 = 0x9275;
2315
2316pub const COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: u32 = 0x9277;
2317
2318pub const COMPRESSED_SRGB_ALPHA: u32 = 0x8C49;
2319
2320pub const COMPRESSED_SRGB_ALPHA_BPTC_UNORM: u32 = 0x8E8D;
2321
2322pub const COMPRESSED_RGB_S3TC_DXT1_EXT: u32 = 0x83F0;
2323
2324pub const COMPRESSED_RGBA_S3TC_DXT1_EXT: u32 = 0x83F1;
2325
2326pub const COMPRESSED_RGBA_S3TC_DXT3_EXT: u32 = 0x83F2;
2327
2328pub const COMPRESSED_RGBA_S3TC_DXT5_EXT: u32 = 0x83F3;
2329
2330pub const COMPRESSED_SRGB_S3TC_DXT1_EXT: u32 = 0x8C4C;
2331
2332pub const COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: u32 = 0x8C4D;
2333
2334pub const COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: u32 = 0x8C4E;
2335
2336pub const COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: u32 = 0x8C4F;
2337
2338pub const COMPRESSED_RGBA_ASTC_4x4_KHR: u32 = 0x93B0;
2339
2340pub const COMPRESSED_RGBA_ASTC_5x4_KHR: u32 = 0x93B1;
2341
2342pub const COMPRESSED_RGBA_ASTC_5x5_KHR: u32 = 0x93B2;
2343
2344pub const COMPRESSED_RGBA_ASTC_6x5_KHR: u32 = 0x93B3;
2345
2346pub const COMPRESSED_RGBA_ASTC_6x6_KHR: u32 = 0x93B4;
2347
2348pub const COMPRESSED_RGBA_ASTC_8x5_KHR: u32 = 0x93B5;
2349
2350pub const COMPRESSED_RGBA_ASTC_8x6_KHR: u32 = 0x93B6;
2351
2352pub const COMPRESSED_RGBA_ASTC_8x8_KHR: u32 = 0x93B7;
2353
2354pub const COMPRESSED_RGBA_ASTC_10x5_KHR: u32 = 0x93B8;
2355
2356pub const COMPRESSED_RGBA_ASTC_10x6_KHR: u32 = 0x93B9;
2357
2358pub const COMPRESSED_RGBA_ASTC_10x8_KHR: u32 = 0x93BA;
2359
2360pub const COMPRESSED_RGBA_ASTC_10x10_KHR: u32 = 0x93BB;
2361
2362pub const COMPRESSED_RGBA_ASTC_12x10_KHR: u32 = 0x93BC;
2363
2364pub const COMPRESSED_RGBA_ASTC_12x12_KHR: u32 = 0x93BD;
2365
2366pub const COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: u32 = 0x93D0;
2367
2368pub const COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: u32 = 0x93D1;
2369
2370pub const COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: u32 = 0x93D2;
2371
2372pub const COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: u32 = 0x93D3;
2373
2374pub const COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: u32 = 0x93D4;
2375
2376pub const COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: u32 = 0x93D5;
2377
2378pub const COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: u32 = 0x93D6;
2379
2380pub const COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: u32 = 0x93D7;
2381
2382pub const COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: u32 = 0x93D8;
2383
2384pub const COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: u32 = 0x93D9;
2385
2386pub const COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: u32 = 0x93DA;
2387
2388pub const COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: u32 = 0x93DB;
2389
2390pub const COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: u32 = 0x93DC;
2391
2392pub const COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: u32 = 0x93DD;
2393
2394pub const COMPRESSED_TEXTURE_FORMATS: u32 = 0x86A3;
2395
2396pub const COMPUTE_SHADER: u32 = 0x91B9;
2397
2398pub const COMPUTE_SHADER_BIT: u32 = 0x00000020;
2399
2400pub const COMPUTE_SHADER_INVOCATIONS: u32 = 0x82F5;
2401
2402pub const COMPUTE_SUBROUTINE: u32 = 0x92ED;
2403
2404pub const COMPUTE_SUBROUTINE_UNIFORM: u32 = 0x92F3;
2405
2406pub const COMPUTE_TEXTURE: u32 = 0x82A0;
2407
2408pub const COMPUTE_WORK_GROUP_SIZE: u32 = 0x8267;
2409
2410pub const CONDITION_SATISFIED: u32 = 0x911C;
2411
2412pub const CONSTANT_ALPHA: u32 = 0x8003;
2413
2414pub const CONSTANT_COLOR: u32 = 0x8001;
2415
2416pub const CONTEXT_COMPATIBILITY_PROFILE_BIT: u32 = 0x00000002;
2417
2418pub const CONTEXT_CORE_PROFILE_BIT: u32 = 0x00000001;
2419
2420pub const CONTEXT_FLAGS: u32 = 0x821E;
2421
2422pub const CONTEXT_FLAG_DEBUG_BIT: u32 = 0x00000002;
2423
2424pub const CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT: u32 = 0x00000001;
2425
2426pub const CONTEXT_FLAG_NO_ERROR_BIT: u32 = 0x00000008;
2427
2428pub const CONTEXT_FLAG_ROBUST_ACCESS_BIT: u32 = 0x00000004;
2429
2430pub const CONTEXT_LOST: u32 = 0x0507;
2431
2432pub const CONTEXT_PROFILE_MASK: u32 = 0x9126;
2433
2434pub const CONTEXT_RELEASE_BEHAVIOR: u32 = 0x82FB;
2435
2436pub const CONTEXT_RELEASE_BEHAVIOR_FLUSH: u32 = 0x82FC;
2437
2438pub const COPY: u32 = 0x1503;
2439
2440pub const COPY_INVERTED: u32 = 0x150C;
2441
2442pub const COPY_READ_BUFFER: u32 = 0x8F36;
2443
2444pub const COPY_READ_BUFFER_BINDING: u32 = 0x8F36;
2445
2446pub const COPY_WRITE_BUFFER: u32 = 0x8F37;
2447
2448pub const COPY_WRITE_BUFFER_BINDING: u32 = 0x8F37;
2449
2450pub const CULL_FACE: u32 = 0x0B44;
2451
2452pub const CULL_FACE_MODE: u32 = 0x0B45;
2453
2454pub const CURRENT_PROGRAM: u32 = 0x8B8D;
2455
2456pub const CURRENT_QUERY: u32 = 0x8865;
2457
2458pub const CURRENT_VERTEX_ATTRIB: u32 = 0x8626;
2459
2460pub const CW: u32 = 0x0900;
2461
2462pub const DEBUG_CALLBACK_FUNCTION: u32 = 0x8244;
2463
2464pub const DEBUG_CALLBACK_USER_PARAM: u32 = 0x8245;
2465
2466pub const DEBUG_GROUP_STACK_DEPTH: u32 = 0x826D;
2467
2468pub const DEBUG_LOGGED_MESSAGES: u32 = 0x9145;
2469
2470pub const DEBUG_NEXT_LOGGED_MESSAGE_LENGTH: u32 = 0x8243;
2471
2472pub const DEBUG_OUTPUT: u32 = 0x92E0;
2473
2474pub const DEBUG_OUTPUT_SYNCHRONOUS: u32 = 0x8242;
2475
2476pub const DEBUG_SEVERITY_HIGH: u32 = 0x9146;
2477
2478pub const DEBUG_SEVERITY_LOW: u32 = 0x9148;
2479
2480pub const DEBUG_SEVERITY_MEDIUM: u32 = 0x9147;
2481
2482pub const DEBUG_SEVERITY_NOTIFICATION: u32 = 0x826B;
2483
2484pub const DEBUG_SOURCE_API: u32 = 0x8246;
2485
2486pub const DEBUG_SOURCE_APPLICATION: u32 = 0x824A;
2487
2488pub const DEBUG_SOURCE_OTHER: u32 = 0x824B;
2489
2490pub const DEBUG_SOURCE_SHADER_COMPILER: u32 = 0x8248;
2491
2492pub const DEBUG_SOURCE_THIRD_PARTY: u32 = 0x8249;
2493
2494pub const DEBUG_SOURCE_WINDOW_SYSTEM: u32 = 0x8247;
2495
2496pub const DEBUG_TYPE_DEPRECATED_BEHAVIOR: u32 = 0x824D;
2497
2498pub const DEBUG_TYPE_ERROR: u32 = 0x824C;
2499
2500pub const DEBUG_TYPE_MARKER: u32 = 0x8268;
2501
2502pub const DEBUG_TYPE_OTHER: u32 = 0x8251;
2503
2504pub const DEBUG_TYPE_PERFORMANCE: u32 = 0x8250;
2505
2506pub const DEBUG_TYPE_POP_GROUP: u32 = 0x826A;
2507
2508pub const DEBUG_TYPE_PORTABILITY: u32 = 0x824F;
2509
2510pub const DEBUG_TYPE_PUSH_GROUP: u32 = 0x8269;
2511
2512pub const DEBUG_TYPE_UNDEFINED_BEHAVIOR: u32 = 0x824E;
2513
2514pub const DECR: u32 = 0x1E03;
2515
2516pub const DECR_WRAP: u32 = 0x8508;
2517
2518pub const DELETE_STATUS: u32 = 0x8B80;
2519
2520pub const DEPTH: u32 = 0x1801;
2521
2522pub const DEPTH24_STENCIL8: u32 = 0x88F0;
2523
2524pub const DEPTH32F_STENCIL8: u32 = 0x8CAD;
2525
2526pub const DEPTH_ATTACHMENT: u32 = 0x8D00;
2527
2528pub const DEPTH_BITS: u32 = 0x0D56;
2529
2530pub const DEPTH_BUFFER_BIT: u32 = 0x00000100;
2531
2532pub const DEPTH_CLAMP: u32 = 0x864F;
2533
2534pub const DEPTH_CLEAR_VALUE: u32 = 0x0B73;
2535
2536pub const DEPTH_COMPONENT: u32 = 0x1902;
2537
2538pub const DEPTH_COMPONENT16: u32 = 0x81A5;
2539
2540pub const DEPTH_COMPONENT24: u32 = 0x81A6;
2541
2542pub const DEPTH_COMPONENT32: u32 = 0x81A7;
2543
2544pub const DEPTH_COMPONENT32F: u32 = 0x8CAC;
2545
2546pub const DEPTH_COMPONENTS: u32 = 0x8284;
2547
2548pub const DEPTH_FUNC: u32 = 0x0B74;
2549
2550pub const DEPTH_RANGE: u32 = 0x0B70;
2551
2552pub const DEPTH_RENDERABLE: u32 = 0x8287;
2553
2554pub const DEPTH_STENCIL: u32 = 0x84F9;
2555
2556pub const DEPTH_STENCIL_ATTACHMENT: u32 = 0x821A;
2557
2558pub const DEPTH_STENCIL_TEXTURE_MODE: u32 = 0x90EA;
2559
2560pub const DEPTH_TEST: u32 = 0x0B71;
2561
2562pub const DEPTH_WRITEMASK: u32 = 0x0B72;
2563
2564pub const DISPATCH_INDIRECT_BUFFER: u32 = 0x90EE;
2565
2566pub const DISPATCH_INDIRECT_BUFFER_BINDING: u32 = 0x90EF;
2567
2568pub const DISPLAY_LIST: u32 = 0x82E7;
2569
2570pub const DITHER: u32 = 0x0BD0;
2571
2572pub const DONT_CARE: u32 = 0x1100;
2573
2574pub const DOUBLE: u32 = 0x140A;
2575
2576pub const DOUBLEBUFFER: u32 = 0x0C32;
2577
2578pub const DOUBLE_MAT2: u32 = 0x8F46;
2579
2580pub const DOUBLE_MAT2x3: u32 = 0x8F49;
2581
2582pub const DOUBLE_MAT2x4: u32 = 0x8F4A;
2583
2584pub const DOUBLE_MAT3: u32 = 0x8F47;
2585
2586pub const DOUBLE_MAT3x2: u32 = 0x8F4B;
2587
2588pub const DOUBLE_MAT3x4: u32 = 0x8F4C;
2589
2590pub const DOUBLE_MAT4: u32 = 0x8F48;
2591
2592pub const DOUBLE_MAT4x2: u32 = 0x8F4D;
2593
2594pub const DOUBLE_MAT4x3: u32 = 0x8F4E;
2595
2596pub const DOUBLE_VEC2: u32 = 0x8FFC;
2597
2598pub const DOUBLE_VEC3: u32 = 0x8FFD;
2599
2600pub const DOUBLE_VEC4: u32 = 0x8FFE;
2601
2602pub const DRAW_BUFFER: u32 = 0x0C01;
2603
2604pub const DRAW_BUFFER0: u32 = 0x8825;
2605
2606pub const DRAW_BUFFER1: u32 = 0x8826;
2607
2608pub const DRAW_BUFFER10: u32 = 0x882F;
2609
2610pub const DRAW_BUFFER11: u32 = 0x8830;
2611
2612pub const DRAW_BUFFER12: u32 = 0x8831;
2613
2614pub const DRAW_BUFFER13: u32 = 0x8832;
2615
2616pub const DRAW_BUFFER14: u32 = 0x8833;
2617
2618pub const DRAW_BUFFER15: u32 = 0x8834;
2619
2620pub const DRAW_BUFFER2: u32 = 0x8827;
2621
2622pub const DRAW_BUFFER3: u32 = 0x8828;
2623
2624pub const DRAW_BUFFER4: u32 = 0x8829;
2625
2626pub const DRAW_BUFFER5: u32 = 0x882A;
2627
2628pub const DRAW_BUFFER6: u32 = 0x882B;
2629
2630pub const DRAW_BUFFER7: u32 = 0x882C;
2631
2632pub const DRAW_BUFFER8: u32 = 0x882D;
2633
2634pub const DRAW_BUFFER9: u32 = 0x882E;
2635
2636pub const DRAW_FRAMEBUFFER: u32 = 0x8CA9;
2637
2638pub const DRAW_FRAMEBUFFER_BINDING: u32 = 0x8CA6;
2639
2640pub const DRAW_INDIRECT_BUFFER: u32 = 0x8F3F;
2641
2642pub const DRAW_INDIRECT_BUFFER_BINDING: u32 = 0x8F43;
2643
2644pub const DST_ALPHA: u32 = 0x0304;
2645
2646pub const DST_COLOR: u32 = 0x0306;
2647
2648pub const DYNAMIC_COPY: u32 = 0x88EA;
2649
2650pub const DYNAMIC_DRAW: u32 = 0x88E8;
2651
2652pub const DYNAMIC_READ: u32 = 0x88E9;
2653
2654pub const DYNAMIC_STORAGE_BIT: u32 = 0x0100;
2655
2656pub const ELEMENT_ARRAY_BARRIER_BIT: u32 = 0x00000002;
2657
2658pub const ELEMENT_ARRAY_BUFFER: u32 = 0x8893;
2659
2660pub const ELEMENT_ARRAY_BUFFER_BINDING: u32 = 0x8895;
2661
2662pub const EQUAL: u32 = 0x0202;
2663
2664pub const EQUIV: u32 = 0x1509;
2665
2666pub const EXTENSIONS: u32 = 0x1F03;
2667
2668pub const FALSE: u8 = 0;
2669
2670pub const FASTEST: u32 = 0x1101;
2671
2672pub const FILL: u32 = 0x1B02;
2673
2674pub const FILTER: u32 = 0x829A;
2675
2676pub const FIRST_VERTEX_CONVENTION: u32 = 0x8E4D;
2677
2678pub const FIXED: u32 = 0x140C;
2679
2680pub const FIXED_ONLY: u32 = 0x891D;
2681
2682pub const FLOAT: u32 = 0x1406;
2683
2684pub const FLOAT_32_UNSIGNED_INT_24_8_REV: u32 = 0x8DAD;
2685
2686pub const FLOAT_MAT2: u32 = 0x8B5A;
2687
2688pub const FLOAT_MAT2x3: u32 = 0x8B65;
2689
2690pub const FLOAT_MAT2x4: u32 = 0x8B66;
2691
2692pub const FLOAT_MAT3: u32 = 0x8B5B;
2693
2694pub const FLOAT_MAT3x2: u32 = 0x8B67;
2695
2696pub const FLOAT_MAT3x4: u32 = 0x8B68;
2697
2698pub const FLOAT_MAT4: u32 = 0x8B5C;
2699
2700pub const FLOAT_MAT4x2: u32 = 0x8B69;
2701
2702pub const FLOAT_MAT4x3: u32 = 0x8B6A;
2703
2704pub const FLOAT_VEC2: u32 = 0x8B50;
2705
2706pub const FLOAT_VEC3: u32 = 0x8B51;
2707
2708pub const FLOAT_VEC4: u32 = 0x8B52;
2709
2710pub const FRACTIONAL_EVEN: u32 = 0x8E7C;
2711
2712pub const FRACTIONAL_ODD: u32 = 0x8E7B;
2713
2714pub const FRAGMENT_INTERPOLATION_OFFSET_BITS: u32 = 0x8E5D;
2715
2716pub const FRAGMENT_SHADER: u32 = 0x8B30;
2717
2718pub const FRAGMENT_SHADER_BIT: u32 = 0x00000002;
2719
2720pub const FRAGMENT_SHADER_DERIVATIVE_HINT: u32 = 0x8B8B;
2721
2722pub const FRAGMENT_SHADER_INVOCATIONS: u32 = 0x82F4;
2723
2724pub const FRAGMENT_SUBROUTINE: u32 = 0x92EC;
2725
2726pub const FRAGMENT_SUBROUTINE_UNIFORM: u32 = 0x92F2;
2727
2728pub const FRAGMENT_TEXTURE: u32 = 0x829F;
2729
2730pub const FRAMEBUFFER: u32 = 0x8D40;
2731
2732pub const FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: u32 = 0x8215;
2733
2734pub const FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: u32 = 0x8214;
2735
2736pub const FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: u32 = 0x8210;
2737
2738pub const FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: u32 = 0x8211;
2739
2740pub const FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: u32 = 0x8216;
2741
2742pub const FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: u32 = 0x8213;
2743
2744pub const FRAMEBUFFER_ATTACHMENT_LAYERED: u32 = 0x8DA7;
2745
2746pub const FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: u32 = 0x8CD1;
2747
2748pub const FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: u32 = 0x8CD0;
2749
2750pub const FRAMEBUFFER_ATTACHMENT_RED_SIZE: u32 = 0x8212;
2751
2752pub const FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: u32 = 0x8217;
2753
2754pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: u32 = 0x8CD3;
2755
2756pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: u32 = 0x8CD4;
2757
2758pub const FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: u32 = 0x8CD2;
2759
2760pub const FRAMEBUFFER_BARRIER_BIT: u32 = 0x00000400;
2761
2762pub const FRAMEBUFFER_BINDING: u32 = 0x8CA6;
2763
2764pub const FRAMEBUFFER_BLEND: u32 = 0x828B;
2765
2766pub const FRAMEBUFFER_COMPLETE: u32 = 0x8CD5;
2767
2768pub const FRAMEBUFFER_DEFAULT: u32 = 0x8218;
2769
2770pub const FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS: u32 = 0x9314;
2771
2772pub const FRAMEBUFFER_DEFAULT_HEIGHT: u32 = 0x9311;
2773
2774pub const FRAMEBUFFER_DEFAULT_LAYERS: u32 = 0x9312;
2775
2776pub const FRAMEBUFFER_DEFAULT_SAMPLES: u32 = 0x9313;
2777
2778pub const FRAMEBUFFER_DEFAULT_WIDTH: u32 = 0x9310;
2779
2780pub const FRAMEBUFFER_INCOMPLETE_ATTACHMENT: u32 = 0x8CD6;
2781
2782pub const FRAMEBUFFER_INCOMPLETE_DIMENSIONS: u32 = 0x8CD9;
2783
2784pub const FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER: u32 = 0x8CDB;
2785
2786pub const FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS: u32 = 0x8DA8;
2787
2788pub const FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: u32 = 0x8CD7;
2789
2790pub const FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: u32 = 0x8D56;
2791
2792pub const FRAMEBUFFER_INCOMPLETE_READ_BUFFER: u32 = 0x8CDC;
2793
2794pub const FRAMEBUFFER_RENDERABLE: u32 = 0x8289;
2795
2796pub const FRAMEBUFFER_RENDERABLE_LAYERED: u32 = 0x828A;
2797
2798pub const FRAMEBUFFER_SRGB: u32 = 0x8DB9;
2799
2800pub const FRAMEBUFFER_UNDEFINED: u32 = 0x8219;
2801
2802pub const FRAMEBUFFER_UNSUPPORTED: u32 = 0x8CDD;
2803
2804pub const FRONT: u32 = 0x0404;
2805
2806pub const FRONT_AND_BACK: u32 = 0x0408;
2807
2808pub const FRONT_FACE: u32 = 0x0B46;
2809
2810pub const FRONT_LEFT: u32 = 0x0400;
2811
2812pub const FRONT_RIGHT: u32 = 0x0401;
2813
2814pub const FULL_SUPPORT: u32 = 0x82B7;
2815
2816pub const FUNC_ADD: u32 = 0x8006;
2817
2818pub const FUNC_REVERSE_SUBTRACT: u32 = 0x800B;
2819
2820pub const FUNC_SUBTRACT: u32 = 0x800A;
2821
2822pub const GENERATE_MIPMAP_HINT: u32 = 0x8192;
2823
2824pub const GEOMETRY_INPUT_TYPE: u32 = 0x8917;
2825
2826pub const GEOMETRY_OUTPUT_TYPE: u32 = 0x8918;
2827
2828pub const GEOMETRY_SHADER: u32 = 0x8DD9;
2829
2830pub const GEOMETRY_SHADER_BIT: u32 = 0x00000004;
2831
2832pub const GEOMETRY_SHADER_INVOCATIONS: u32 = 0x887F;
2833
2834pub const GEOMETRY_SHADER_PRIMITIVES_EMITTED: u32 = 0x82F3;
2835
2836pub const GEOMETRY_SUBROUTINE: u32 = 0x92EB;
2837
2838pub const GEOMETRY_SUBROUTINE_UNIFORM: u32 = 0x92F1;
2839
2840pub const GEOMETRY_TEXTURE: u32 = 0x829E;
2841
2842pub const GEOMETRY_VERTICES_OUT: u32 = 0x8916;
2843
2844pub const GEQUAL: u32 = 0x0206;
2845
2846pub const GET_TEXTURE_IMAGE_FORMAT: u32 = 0x8291;
2847
2848pub const GET_TEXTURE_IMAGE_TYPE: u32 = 0x8292;
2849
2850pub const GREATER: u32 = 0x0204;
2851
2852pub const GREEN: u32 = 0x1904;
2853
2854pub const GREEN_BITS: u32 = 0x0D53;
2855
2856pub const GREEN_INTEGER: u32 = 0x8D95;
2857
2858pub const GUILTY_CONTEXT_RESET: u32 = 0x8253;
2859
2860pub const HALF_FLOAT_OES: u32 = 0x8D61;
2861
2862pub const HALF_FLOAT: u32 = 0x140B;
2863
2864pub const HIGH_FLOAT: u32 = 0x8DF2;
2865
2866pub const HIGH_INT: u32 = 0x8DF5;
2867
2868pub const IMAGE_1D: u32 = 0x904C;
2869
2870pub const IMAGE_1D_ARRAY: u32 = 0x9052;
2871
2872pub const IMAGE_2D: u32 = 0x904D;
2873
2874pub const IMAGE_2D_ARRAY: u32 = 0x9053;
2875
2876pub const IMAGE_2D_MULTISAMPLE: u32 = 0x9055;
2877
2878pub const IMAGE_2D_MULTISAMPLE_ARRAY: u32 = 0x9056;
2879
2880pub const IMAGE_2D_RECT: u32 = 0x904F;
2881
2882pub const IMAGE_3D: u32 = 0x904E;
2883
2884pub const IMAGE_BINDING_ACCESS: u32 = 0x8F3E;
2885
2886pub const IMAGE_BINDING_FORMAT: u32 = 0x906E;
2887
2888pub const IMAGE_BINDING_LAYER: u32 = 0x8F3D;
2889
2890pub const IMAGE_BINDING_LAYERED: u32 = 0x8F3C;
2891
2892pub const IMAGE_BINDING_LEVEL: u32 = 0x8F3B;
2893
2894pub const IMAGE_BINDING_NAME: u32 = 0x8F3A;
2895
2896pub const IMAGE_BUFFER: u32 = 0x9051;
2897
2898pub const IMAGE_CLASS_10_10_10_2: u32 = 0x82C3;
2899
2900pub const IMAGE_CLASS_11_11_10: u32 = 0x82C2;
2901
2902pub const IMAGE_CLASS_1_X_16: u32 = 0x82BE;
2903
2904pub const IMAGE_CLASS_1_X_32: u32 = 0x82BB;
2905
2906pub const IMAGE_CLASS_1_X_8: u32 = 0x82C1;
2907
2908pub const IMAGE_CLASS_2_X_16: u32 = 0x82BD;
2909
2910pub const IMAGE_CLASS_2_X_32: u32 = 0x82BA;
2911
2912pub const IMAGE_CLASS_2_X_8: u32 = 0x82C0;
2913
2914pub const IMAGE_CLASS_4_X_16: u32 = 0x82BC;
2915
2916pub const IMAGE_CLASS_4_X_32: u32 = 0x82B9;
2917
2918pub const IMAGE_CLASS_4_X_8: u32 = 0x82BF;
2919
2920pub const IMAGE_COMPATIBILITY_CLASS: u32 = 0x82A8;
2921
2922pub const IMAGE_CUBE: u32 = 0x9050;
2923
2924pub const IMAGE_CUBE_MAP_ARRAY: u32 = 0x9054;
2925
2926pub const IMAGE_FORMAT_COMPATIBILITY_BY_CLASS: u32 = 0x90C9;
2927
2928pub const IMAGE_FORMAT_COMPATIBILITY_BY_SIZE: u32 = 0x90C8;
2929
2930pub const IMAGE_FORMAT_COMPATIBILITY_TYPE: u32 = 0x90C7;
2931
2932pub const IMAGE_PIXEL_FORMAT: u32 = 0x82A9;
2933
2934pub const IMAGE_PIXEL_TYPE: u32 = 0x82AA;
2935
2936pub const IMAGE_TEXEL_SIZE: u32 = 0x82A7;
2937
2938pub const IMPLEMENTATION_COLOR_READ_FORMAT: u32 = 0x8B9B;
2939
2940pub const IMPLEMENTATION_COLOR_READ_TYPE: u32 = 0x8B9A;
2941
2942pub const INCR: u32 = 0x1E02;
2943
2944pub const INCR_WRAP: u32 = 0x8507;
2945
2946pub const INDEX: u32 = 0x8222;
2947
2948pub const INFO_LOG_LENGTH: u32 = 0x8B84;
2949
2950pub const INNOCENT_CONTEXT_RESET: u32 = 0x8254;
2951
2952pub const INT: u32 = 0x1404;
2953
2954pub const INTERLEAVED_ATTRIBS: u32 = 0x8C8C;
2955
2956pub const INTERNALFORMAT_ALPHA_SIZE: u32 = 0x8274;
2957
2958pub const INTERNALFORMAT_ALPHA_TYPE: u32 = 0x827B;
2959
2960pub const INTERNALFORMAT_BLUE_SIZE: u32 = 0x8273;
2961
2962pub const INTERNALFORMAT_BLUE_TYPE: u32 = 0x827A;
2963
2964pub const INTERNALFORMAT_DEPTH_SIZE: u32 = 0x8275;
2965
2966pub const INTERNALFORMAT_DEPTH_TYPE: u32 = 0x827C;
2967
2968pub const INTERNALFORMAT_GREEN_SIZE: u32 = 0x8272;
2969
2970pub const INTERNALFORMAT_GREEN_TYPE: u32 = 0x8279;
2971
2972pub const INTERNALFORMAT_PREFERRED: u32 = 0x8270;
2973
2974pub const INTERNALFORMAT_RED_SIZE: u32 = 0x8271;
2975
2976pub const INTERNALFORMAT_RED_TYPE: u32 = 0x8278;
2977
2978pub const INTERNALFORMAT_SHARED_SIZE: u32 = 0x8277;
2979
2980pub const INTERNALFORMAT_STENCIL_SIZE: u32 = 0x8276;
2981
2982pub const INTERNALFORMAT_STENCIL_TYPE: u32 = 0x827D;
2983
2984pub const INTERNALFORMAT_SUPPORTED: u32 = 0x826F;
2985
2986pub const INT_2_10_10_10_REV: u32 = 0x8D9F;
2987
2988pub const INT_IMAGE_1D: u32 = 0x9057;
2989
2990pub const INT_IMAGE_1D_ARRAY: u32 = 0x905D;
2991
2992pub const INT_IMAGE_2D: u32 = 0x9058;
2993
2994pub const INT_IMAGE_2D_ARRAY: u32 = 0x905E;
2995
2996pub const INT_IMAGE_2D_MULTISAMPLE: u32 = 0x9060;
2997
2998pub const INT_IMAGE_2D_MULTISAMPLE_ARRAY: u32 = 0x9061;
2999
3000pub const INT_IMAGE_2D_RECT: u32 = 0x905A;
3001
3002pub const INT_IMAGE_3D: u32 = 0x9059;
3003
3004pub const INT_IMAGE_BUFFER: u32 = 0x905C;
3005
3006pub const INT_IMAGE_CUBE: u32 = 0x905B;
3007
3008pub const INT_IMAGE_CUBE_MAP_ARRAY: u32 = 0x905F;
3009
3010pub const INT_SAMPLER_1D: u32 = 0x8DC9;
3011
3012pub const INT_SAMPLER_1D_ARRAY: u32 = 0x8DCE;
3013
3014pub const INT_SAMPLER_2D: u32 = 0x8DCA;
3015
3016pub const INT_SAMPLER_2D_ARRAY: u32 = 0x8DCF;
3017
3018pub const INT_SAMPLER_2D_MULTISAMPLE: u32 = 0x9109;
3019
3020pub const INT_SAMPLER_2D_MULTISAMPLE_ARRAY: u32 = 0x910C;
3021
3022pub const INT_SAMPLER_2D_RECT: u32 = 0x8DCD;
3023
3024pub const INT_SAMPLER_3D: u32 = 0x8DCB;
3025
3026pub const INT_SAMPLER_BUFFER: u32 = 0x8DD0;
3027
3028pub const INT_SAMPLER_CUBE: u32 = 0x8DCC;
3029
3030pub const INT_SAMPLER_CUBE_MAP_ARRAY: u32 = 0x900E;
3031
3032pub const INT_VEC2: u32 = 0x8B53;
3033
3034pub const INT_VEC3: u32 = 0x8B54;
3035
3036pub const INT_VEC4: u32 = 0x8B55;
3037
3038pub const INVALID_ENUM: u32 = 0x0500;
3039
3040pub const INVALID_FRAMEBUFFER_OPERATION: u32 = 0x0506;
3041
3042pub const INVALID_INDEX: u32 = 0xFFFFFFFF;
3043
3044pub const INVALID_OPERATION: u32 = 0x0502;
3045
3046pub const INVALID_VALUE: u32 = 0x0501;
3047
3048pub const INVERT: u32 = 0x150A;
3049
3050pub const ISOLINES: u32 = 0x8E7A;
3051
3052pub const IS_PER_PATCH: u32 = 0x92E7;
3053
3054pub const IS_ROW_MAJOR: u32 = 0x9300;
3055
3056pub const KEEP: u32 = 0x1E00;
3057
3058pub const LAST_VERTEX_CONVENTION: u32 = 0x8E4E;
3059
3060pub const LAYER_PROVOKING_VERTEX: u32 = 0x825E;
3061
3062pub const LEFT: u32 = 0x0406;
3063
3064pub const LEQUAL: u32 = 0x0203;
3065
3066pub const LESS: u32 = 0x0201;
3067
3068pub const LINE: u32 = 0x1B01;
3069
3070pub const LINEAR: u32 = 0x2601;
3071
3072pub const LINEAR_MIPMAP_LINEAR: u32 = 0x2703;
3073
3074pub const LINEAR_MIPMAP_NEAREST: u32 = 0x2701;
3075
3076pub const LINES: u32 = 0x0001;
3077
3078pub const LINES_ADJACENCY: u32 = 0x000A;
3079
3080pub const LINE_LOOP: u32 = 0x0002;
3081
3082pub const LINE_SMOOTH: u32 = 0x0B20;
3083
3084pub const LINE_SMOOTH_HINT: u32 = 0x0C52;
3085
3086pub const LINE_STRIP: u32 = 0x0003;
3087
3088pub const LINE_STRIP_ADJACENCY: u32 = 0x000B;
3089
3090pub const LINE_WIDTH: u32 = 0x0B21;
3091
3092pub const LINE_WIDTH_GRANULARITY: u32 = 0x0B23;
3093
3094pub const LINE_WIDTH_RANGE: u32 = 0x0B22;
3095
3096pub const LINK_STATUS: u32 = 0x8B82;
3097
3098pub const LOCATION: u32 = 0x930E;
3099
3100pub const LOCATION_COMPONENT: u32 = 0x934A;
3101
3102pub const LOCATION_INDEX: u32 = 0x930F;
3103
3104pub const LOGIC_OP_MODE: u32 = 0x0BF0;
3105
3106pub const LOSE_CONTEXT_ON_RESET: u32 = 0x8252;
3107
3108pub const LOWER_LEFT: u32 = 0x8CA1;
3109
3110pub const LOW_FLOAT: u32 = 0x8DF0;
3111
3112pub const LOW_INT: u32 = 0x8DF3;
3113
3114pub const LUMINANCE: u32 = 0x1909;
3115
3116pub const LUMINANCE_ALPHA: u32 = 0x190A;
3117
3118pub const MAJOR_VERSION: u32 = 0x821B;
3119
3120pub const MANUAL_GENERATE_MIPMAP: u32 = 0x8294;
3121
3122pub const MAP_COHERENT_BIT: u32 = 0x0080;
3123
3124pub const MAP_FLUSH_EXPLICIT_BIT: u32 = 0x0010;
3125
3126pub const MAP_INVALIDATE_BUFFER_BIT: u32 = 0x0008;
3127
3128pub const MAP_INVALIDATE_RANGE_BIT: u32 = 0x0004;
3129
3130pub const MAP_PERSISTENT_BIT: u32 = 0x0040;
3131
3132pub const MAP_READ_BIT: u32 = 0x0001;
3133
3134pub const MAP_UNSYNCHRONIZED_BIT: u32 = 0x0020;
3135
3136pub const MAP_WRITE_BIT: u32 = 0x0002;
3137
3138pub const MATRIX_STRIDE: u32 = 0x92FF;
3139
3140pub const MAX: u32 = 0x8008;
3141
3142pub const MAX_3D_TEXTURE_SIZE: u32 = 0x8073;
3143
3144pub const MAX_ARRAY_TEXTURE_LAYERS: u32 = 0x88FF;
3145
3146pub const MAX_ATOMIC_COUNTER_BUFFER_BINDINGS: u32 = 0x92DC;
3147
3148pub const MAX_ATOMIC_COUNTER_BUFFER_SIZE: u32 = 0x92D8;
3149
3150pub const MAX_CLIP_DISTANCES: u32 = 0x0D32;
3151
3152pub const MAX_COLOR_ATTACHMENTS: u32 = 0x8CDF;
3153
3154pub const MAX_COLOR_TEXTURE_SAMPLES: u32 = 0x910E;
3155
3156pub const MAX_COMBINED_ATOMIC_COUNTERS: u32 = 0x92D7;
3157
3158pub const MAX_COMBINED_ATOMIC_COUNTER_BUFFERS: u32 = 0x92D1;
3159
3160pub const MAX_COMBINED_CLIP_AND_CULL_DISTANCES: u32 = 0x82FA;
3161
3162pub const MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS: u32 = 0x8266;
3163
3164pub const MAX_COMBINED_DIMENSIONS: u32 = 0x8282;
3165
3166pub const MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: u32 = 0x8A33;
3167
3168pub const MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS: u32 = 0x8A32;
3169
3170pub const MAX_COMBINED_IMAGE_UNIFORMS: u32 = 0x90CF;
3171
3172pub const MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS: u32 = 0x8F39;
3173
3174pub const MAX_COMBINED_SHADER_OUTPUT_RESOURCES: u32 = 0x8F39;
3175
3176pub const MAX_COMBINED_SHADER_STORAGE_BLOCKS: u32 = 0x90DC;
3177
3178pub const MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS: u32 = 0x8E1E;
3179
3180pub const MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS: u32 = 0x8E1F;
3181
3182pub const MAX_COMBINED_TEXTURE_IMAGE_UNITS: u32 = 0x8B4D;
3183
3184pub const MAX_COMBINED_UNIFORM_BLOCKS: u32 = 0x8A2E;
3185
3186pub const MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: u32 = 0x8A31;
3187
3188pub const MAX_COMPUTE_ATOMIC_COUNTERS: u32 = 0x8265;
3189
3190pub const MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS: u32 = 0x8264;
3191
3192pub const MAX_COMPUTE_IMAGE_UNIFORMS: u32 = 0x91BD;
3193
3194pub const MAX_COMPUTE_SHADER_STORAGE_BLOCKS: u32 = 0x90DB;
3195
3196pub const MAX_COMPUTE_SHARED_MEMORY_SIZE: u32 = 0x8262;
3197
3198pub const MAX_COMPUTE_TEXTURE_IMAGE_UNITS: u32 = 0x91BC;
3199
3200pub const MAX_COMPUTE_UNIFORM_BLOCKS: u32 = 0x91BB;
3201
3202pub const MAX_COMPUTE_UNIFORM_COMPONENTS: u32 = 0x8263;
3203
3204pub const MAX_COMPUTE_WORK_GROUP_COUNT: u32 = 0x91BE;
3205
3206pub const MAX_COMPUTE_WORK_GROUP_INVOCATIONS: u32 = 0x90EB;
3207
3208pub const MAX_COMPUTE_WORK_GROUP_SIZE: u32 = 0x91BF;
3209
3210pub const MAX_CUBE_MAP_TEXTURE_SIZE: u32 = 0x851C;
3211
3212pub const MAX_CULL_DISTANCES: u32 = 0x82F9;
3213
3214pub const MAX_DEBUG_GROUP_STACK_DEPTH: u32 = 0x826C;
3215
3216pub const MAX_DEBUG_LOGGED_MESSAGES: u32 = 0x9144;
3217
3218pub const MAX_DEBUG_MESSAGE_LENGTH: u32 = 0x9143;
3219
3220pub const MAX_DEPTH: u32 = 0x8280;
3221
3222pub const MAX_DEPTH_TEXTURE_SAMPLES: u32 = 0x910F;
3223
3224pub const MAX_DRAW_BUFFERS: u32 = 0x8824;
3225
3226pub const MAX_DUAL_SOURCE_DRAW_BUFFERS: u32 = 0x88FC;
3227
3228pub const MAX_ELEMENTS_INDICES: u32 = 0x80E9;
3229
3230pub const MAX_ELEMENTS_VERTICES: u32 = 0x80E8;
3231
3232pub const MAX_ELEMENT_INDEX: u32 = 0x8D6B;
3233
3234pub const MAX_FRAGMENT_ATOMIC_COUNTERS: u32 = 0x92D6;
3235
3236pub const MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS: u32 = 0x92D0;
3237
3238pub const MAX_FRAGMENT_IMAGE_UNIFORMS: u32 = 0x90CE;
3239
3240pub const MAX_FRAGMENT_INPUT_COMPONENTS: u32 = 0x9125;
3241
3242pub const MAX_FRAGMENT_INTERPOLATION_OFFSET: u32 = 0x8E5C;
3243
3244pub const MAX_FRAGMENT_SHADER_STORAGE_BLOCKS: u32 = 0x90DA;
3245
3246pub const MAX_FRAGMENT_UNIFORM_BLOCKS: u32 = 0x8A2D;
3247
3248pub const MAX_FRAGMENT_UNIFORM_COMPONENTS: u32 = 0x8B49;
3249
3250pub const MAX_FRAGMENT_UNIFORM_VECTORS: u32 = 0x8DFD;
3251
3252pub const MAX_FRAMEBUFFER_HEIGHT: u32 = 0x9316;
3253
3254pub const MAX_FRAMEBUFFER_LAYERS: u32 = 0x9317;
3255
3256pub const MAX_FRAMEBUFFER_SAMPLES: u32 = 0x9318;
3257
3258pub const MAX_FRAMEBUFFER_WIDTH: u32 = 0x9315;
3259
3260pub const MAX_GEOMETRY_ATOMIC_COUNTERS: u32 = 0x92D5;
3261
3262pub const MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS: u32 = 0x92CF;
3263
3264pub const MAX_GEOMETRY_IMAGE_UNIFORMS: u32 = 0x90CD;
3265
3266pub const MAX_GEOMETRY_INPUT_COMPONENTS: u32 = 0x9123;
3267
3268pub const MAX_GEOMETRY_OUTPUT_COMPONENTS: u32 = 0x9124;
3269
3270pub const MAX_GEOMETRY_OUTPUT_VERTICES: u32 = 0x8DE0;
3271
3272pub const MAX_GEOMETRY_SHADER_INVOCATIONS: u32 = 0x8E5A;
3273
3274pub const MAX_GEOMETRY_SHADER_STORAGE_BLOCKS: u32 = 0x90D7;
3275
3276pub const MAX_GEOMETRY_TEXTURE_IMAGE_UNITS: u32 = 0x8C29;
3277
3278pub const MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS: u32 = 0x8DE1;
3279
3280pub const MAX_GEOMETRY_UNIFORM_BLOCKS: u32 = 0x8A2C;
3281
3282pub const MAX_GEOMETRY_UNIFORM_COMPONENTS: u32 = 0x8DDF;
3283
3284pub const MAX_HEIGHT: u32 = 0x827F;
3285
3286pub const MAX_IMAGE_SAMPLES: u32 = 0x906D;
3287
3288pub const MAX_IMAGE_UNITS: u32 = 0x8F38;
3289
3290pub const MAX_INTEGER_SAMPLES: u32 = 0x9110;
3291
3292pub const MAX_LABEL_LENGTH: u32 = 0x82E8;
3293
3294pub const MAX_LAYERS: u32 = 0x8281;
3295
3296pub const MAX_NAME_LENGTH: u32 = 0x92F6;
3297
3298pub const MAX_NUM_ACTIVE_VARIABLES: u32 = 0x92F7;
3299
3300pub const MAX_NUM_COMPATIBLE_SUBROUTINES: u32 = 0x92F8;
3301
3302pub const MAX_PATCH_VERTICES: u32 = 0x8E7D;
3303
3304pub const MAX_PROGRAM_TEXEL_OFFSET: u32 = 0x8905;
3305
3306pub const MAX_PROGRAM_TEXTURE_GATHER_OFFSET: u32 = 0x8E5F;
3307
3308pub const MAX_RECTANGLE_TEXTURE_SIZE: u32 = 0x84F8;
3309
3310pub const MAX_RENDERBUFFER_SIZE: u32 = 0x84E8;
3311
3312pub const MAX_SAMPLES: u32 = 0x8D57;
3313
3314pub const MAX_SAMPLE_MASK_WORDS: u32 = 0x8E59;
3315
3316pub const MAX_SERVER_WAIT_TIMEOUT: u32 = 0x9111;
3317
3318pub const MAX_SHADER_COMPILER_THREADS: u32 = 0x91B0;
3319
3320pub const MAX_SHADER_STORAGE_BLOCK_SIZE: u32 = 0x90DE;
3321
3322pub const MAX_SHADER_STORAGE_BUFFER_BINDINGS: u32 = 0x90DD;
3323
3324pub const MAX_SUBROUTINES: u32 = 0x8DE7;
3325
3326pub const MAX_SUBROUTINE_UNIFORM_LOCATIONS: u32 = 0x8DE8;
3327
3328pub const MAX_TESS_CONTROL_ATOMIC_COUNTERS: u32 = 0x92D3;
3329
3330pub const MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS: u32 = 0x92CD;
3331
3332pub const MAX_TESS_CONTROL_IMAGE_UNIFORMS: u32 = 0x90CB;
3333
3334pub const MAX_TESS_CONTROL_INPUT_COMPONENTS: u32 = 0x886C;
3335
3336pub const MAX_TESS_CONTROL_OUTPUT_COMPONENTS: u32 = 0x8E83;
3337
3338pub const MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS: u32 = 0x90D8;
3339
3340pub const MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS: u32 = 0x8E81;
3341
3342pub const MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS: u32 = 0x8E85;
3343
3344pub const MAX_TESS_CONTROL_UNIFORM_BLOCKS: u32 = 0x8E89;
3345
3346pub const MAX_TESS_CONTROL_UNIFORM_COMPONENTS: u32 = 0x8E7F;
3347
3348pub const MAX_TESS_EVALUATION_ATOMIC_COUNTERS: u32 = 0x92D4;
3349
3350pub const MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS: u32 = 0x92CE;
3351
3352pub const MAX_TESS_EVALUATION_IMAGE_UNIFORMS: u32 = 0x90CC;
3353
3354pub const MAX_TESS_EVALUATION_INPUT_COMPONENTS: u32 = 0x886D;
3355
3356pub const MAX_TESS_EVALUATION_OUTPUT_COMPONENTS: u32 = 0x8E86;
3357
3358pub const MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS: u32 = 0x90D9;
3359
3360pub const MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS: u32 = 0x8E82;
3361
3362pub const MAX_TESS_EVALUATION_UNIFORM_BLOCKS: u32 = 0x8E8A;
3363
3364pub const MAX_TESS_EVALUATION_UNIFORM_COMPONENTS: u32 = 0x8E80;
3365
3366pub const MAX_TESS_GEN_LEVEL: u32 = 0x8E7E;
3367
3368pub const MAX_TESS_PATCH_COMPONENTS: u32 = 0x8E84;
3369
3370pub const MAX_TEXTURE_BUFFER_SIZE: u32 = 0x8C2B;
3371
3372pub const MAX_TEXTURE_IMAGE_UNITS: u32 = 0x8872;
3373
3374pub const MAX_TEXTURE_LOD_BIAS: u32 = 0x84FD;
3375
3376pub const MAX_TEXTURE_MAX_ANISOTROPY: u32 = 0x84FF;
3377
3378pub const MAX_TEXTURE_MAX_ANISOTROPY_EXT: u32 = 0x84FF;
3379
3380pub const MAX_TEXTURE_SIZE: u32 = 0x0D33;
3381
3382pub const MAX_TRANSFORM_FEEDBACK_BUFFERS: u32 = 0x8E70;
3383
3384pub const MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: u32 = 0x8C8A;
3385
3386pub const MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: u32 = 0x8C8B;
3387
3388pub const MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: u32 = 0x8C80;
3389
3390pub const MAX_UNIFORM_BLOCK_SIZE: u32 = 0x8A30;
3391
3392pub const MAX_UNIFORM_BUFFER_BINDINGS: u32 = 0x8A2F;
3393
3394pub const MAX_UNIFORM_LOCATIONS: u32 = 0x826E;
3395
3396pub const MAX_VARYING_COMPONENTS: u32 = 0x8B4B;
3397
3398pub const MAX_VARYING_FLOATS: u32 = 0x8B4B;
3399
3400pub const MAX_VARYING_VECTORS: u32 = 0x8DFC;
3401
3402pub const MAX_VERTEX_ATOMIC_COUNTERS: u32 = 0x92D2;
3403
3404pub const MAX_VERTEX_ATOMIC_COUNTER_BUFFERS: u32 = 0x92CC;
3405
3406pub const MAX_VERTEX_ATTRIBS: u32 = 0x8869;
3407
3408pub const MAX_VERTEX_ATTRIB_BINDINGS: u32 = 0x82DA;
3409
3410pub const MAX_VERTEX_ATTRIB_RELATIVE_OFFSET: u32 = 0x82D9;
3411
3412pub const MAX_VERTEX_ATTRIB_STRIDE: u32 = 0x82E5;
3413
3414pub const MAX_VERTEX_IMAGE_UNIFORMS: u32 = 0x90CA;
3415
3416pub const MAX_VERTEX_OUTPUT_COMPONENTS: u32 = 0x9122;
3417
3418pub const MAX_VERTEX_SHADER_STORAGE_BLOCKS: u32 = 0x90D6;
3419
3420pub const MAX_VERTEX_STREAMS: u32 = 0x8E71;
3421
3422pub const MAX_VERTEX_TEXTURE_IMAGE_UNITS: u32 = 0x8B4C;
3423
3424pub const MAX_VERTEX_UNIFORM_BLOCKS: u32 = 0x8A2B;
3425
3426pub const MAX_VERTEX_UNIFORM_COMPONENTS: u32 = 0x8B4A;
3427
3428pub const MAX_VERTEX_UNIFORM_VECTORS: u32 = 0x8DFB;
3429
3430pub const MAX_VIEWPORTS: u32 = 0x825B;
3431
3432pub const MAX_VIEWPORT_DIMS: u32 = 0x0D3A;
3433
3434pub const MAX_WIDTH: u32 = 0x827E;
3435
3436pub const MEDIUM_FLOAT: u32 = 0x8DF1;
3437
3438pub const MEDIUM_INT: u32 = 0x8DF4;
3439
3440pub const MIN: u32 = 0x8007;
3441
3442pub const MINOR_VERSION: u32 = 0x821C;
3443
3444pub const MIN_FRAGMENT_INTERPOLATION_OFFSET: u32 = 0x8E5B;
3445
3446pub const MIN_MAP_BUFFER_ALIGNMENT: u32 = 0x90BC;
3447
3448pub const MIN_PROGRAM_TEXEL_OFFSET: u32 = 0x8904;
3449
3450pub const MIN_PROGRAM_TEXTURE_GATHER_OFFSET: u32 = 0x8E5E;
3451
3452pub const MIN_SAMPLE_SHADING_VALUE: u32 = 0x8C37;
3453
3454pub const MIPMAP: u32 = 0x8293;
3455
3456pub const MIRRORED_REPEAT: u32 = 0x8370;
3457
3458pub const MIRROR_CLAMP_TO_EDGE: u32 = 0x8743;
3459
3460pub const MULTISAMPLE: u32 = 0x809D;
3461
3462pub const NAME_LENGTH: u32 = 0x92F9;
3463
3464pub const NAND: u32 = 0x150E;
3465
3466pub const NEAREST: u32 = 0x2600;
3467
3468pub const NEAREST_MIPMAP_LINEAR: u32 = 0x2702;
3469
3470pub const NEAREST_MIPMAP_NEAREST: u32 = 0x2700;
3471
3472pub const NEGATIVE_ONE_TO_ONE: u32 = 0x935E;
3473
3474pub const NEVER: u32 = 0x0200;
3475
3476pub const NICEST: u32 = 0x1102;
3477
3478pub const NONE: u32 = 0;
3479
3480pub const NOOP: u32 = 0x1505;
3481
3482pub const NOR: u32 = 0x1508;
3483
3484pub const NOTEQUAL: u32 = 0x0205;
3485
3486pub const NO_ERROR: u32 = 0;
3487
3488pub const NO_RESET_NOTIFICATION: u32 = 0x8261;
3489
3490pub const NUM_ACTIVE_VARIABLES: u32 = 0x9304;
3491
3492pub const NUM_COMPATIBLE_SUBROUTINES: u32 = 0x8E4A;
3493
3494pub const NUM_COMPRESSED_TEXTURE_FORMATS: u32 = 0x86A2;
3495
3496pub const NUM_EXTENSIONS: u32 = 0x821D;
3497
3498pub const NUM_PROGRAM_BINARY_FORMATS: u32 = 0x87FE;
3499
3500pub const NUM_SAMPLE_COUNTS: u32 = 0x9380;
3501
3502pub const NUM_SHADER_BINARY_FORMATS: u32 = 0x8DF9;
3503
3504pub const NUM_SHADING_LANGUAGE_VERSIONS: u32 = 0x82E9;
3505
3506pub const NUM_SPIR_V_EXTENSIONS: u32 = 0x9554;
3507
3508pub const OBJECT_TYPE: u32 = 0x9112;
3509
3510pub const OFFSET: u32 = 0x92FC;
3511
3512pub const ONE: u32 = 1;
3513
3514pub const ONE_MINUS_CONSTANT_ALPHA: u32 = 0x8004;
3515
3516pub const ONE_MINUS_CONSTANT_COLOR: u32 = 0x8002;
3517
3518pub const ONE_MINUS_DST_ALPHA: u32 = 0x0305;
3519
3520pub const ONE_MINUS_DST_COLOR: u32 = 0x0307;
3521
3522pub const ONE_MINUS_SRC1_ALPHA: u32 = 0x88FB;
3523
3524pub const ONE_MINUS_SRC1_COLOR: u32 = 0x88FA;
3525
3526pub const ONE_MINUS_SRC_ALPHA: u32 = 0x0303;
3527
3528pub const ONE_MINUS_SRC_COLOR: u32 = 0x0301;
3529
3530pub const OR: u32 = 0x1507;
3531
3532pub const OR_INVERTED: u32 = 0x150D;
3533
3534pub const OR_REVERSE: u32 = 0x150B;
3535
3536pub const OUT_OF_MEMORY: u32 = 0x0505;
3537
3538pub const PACK_ALIGNMENT: u32 = 0x0D05;
3539
3540pub const PACK_COMPRESSED_BLOCK_DEPTH: u32 = 0x912D;
3541
3542pub const PACK_COMPRESSED_BLOCK_HEIGHT: u32 = 0x912C;
3543
3544pub const PACK_COMPRESSED_BLOCK_SIZE: u32 = 0x912E;
3545
3546pub const PACK_COMPRESSED_BLOCK_WIDTH: u32 = 0x912B;
3547
3548pub const PACK_IMAGE_HEIGHT: u32 = 0x806C;
3549
3550pub const PACK_LSB_FIRST: u32 = 0x0D01;
3551
3552pub const PACK_ROW_LENGTH: u32 = 0x0D02;
3553
3554pub const PACK_SKIP_IMAGES: u32 = 0x806B;
3555
3556pub const PACK_SKIP_PIXELS: u32 = 0x0D04;
3557
3558pub const PACK_SKIP_ROWS: u32 = 0x0D03;
3559
3560pub const PACK_SWAP_BYTES: u32 = 0x0D00;
3561
3562pub const PARAMETER_BUFFER: u32 = 0x80EE;
3563
3564pub const PARAMETER_BUFFER_BINDING: u32 = 0x80EF;
3565
3566pub const PATCHES: u32 = 0x000E;
3567
3568pub const PATCH_DEFAULT_INNER_LEVEL: u32 = 0x8E73;
3569
3570pub const PATCH_DEFAULT_OUTER_LEVEL: u32 = 0x8E74;
3571
3572pub const PATCH_VERTICES: u32 = 0x8E72;
3573
3574pub const PIXEL_BUFFER_BARRIER_BIT: u32 = 0x00000080;
3575
3576pub const PIXEL_PACK_BUFFER: u32 = 0x88EB;
3577
3578pub const PIXEL_PACK_BUFFER_BINDING: u32 = 0x88ED;
3579
3580pub const PIXEL_UNPACK_BUFFER: u32 = 0x88EC;
3581
3582pub const PIXEL_UNPACK_BUFFER_BINDING: u32 = 0x88EF;
3583
3584pub const POINT: u32 = 0x1B00;
3585
3586pub const POINTS: u32 = 0x0000;
3587
3588pub const POINT_FADE_THRESHOLD_SIZE: u32 = 0x8128;
3589
3590pub const POINT_SIZE: u32 = 0x0B11;
3591
3592pub const POINT_SIZE_GRANULARITY: u32 = 0x0B13;
3593
3594pub const POINT_SIZE_RANGE: u32 = 0x0B12;
3595
3596pub const POINT_SPRITE_COORD_ORIGIN: u32 = 0x8CA0;
3597
3598pub const POLYGON_MODE: u32 = 0x0B40;
3599
3600pub const POLYGON_OFFSET_CLAMP: u32 = 0x8E1B;
3601
3602pub const POLYGON_OFFSET_FACTOR: u32 = 0x8038;
3603
3604pub const POLYGON_OFFSET_FILL: u32 = 0x8037;
3605
3606pub const POLYGON_OFFSET_LINE: u32 = 0x2A02;
3607
3608pub const POLYGON_OFFSET_POINT: u32 = 0x2A01;
3609
3610pub const POLYGON_OFFSET_UNITS: u32 = 0x2A00;
3611
3612pub const POLYGON_SMOOTH: u32 = 0x0B41;
3613
3614pub const POLYGON_SMOOTH_HINT: u32 = 0x0C53;
3615
3616pub const PRIMITIVES_GENERATED: u32 = 0x8C87;
3617
3618pub const PRIMITIVES_SUBMITTED: u32 = 0x82EF;
3619
3620pub const PRIMITIVE_RESTART: u32 = 0x8F9D;
3621
3622pub const PRIMITIVE_RESTART_FIXED_INDEX: u32 = 0x8D69;
3623
3624pub const PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED: u32 = 0x8221;
3625
3626pub const PRIMITIVE_RESTART_INDEX: u32 = 0x8F9E;
3627
3628pub const PROGRAM: u32 = 0x82E2;
3629
3630pub const PROGRAM_BINARY_FORMATS: u32 = 0x87FF;
3631
3632pub const PROGRAM_BINARY_LENGTH: u32 = 0x8741;
3633
3634pub const PROGRAM_BINARY_RETRIEVABLE_HINT: u32 = 0x8257;
3635
3636pub const PROGRAM_INPUT: u32 = 0x92E3;
3637
3638pub const PROGRAM_OUTPUT: u32 = 0x92E4;
3639
3640pub const PROGRAM_PIPELINE: u32 = 0x82E4;
3641
3642pub const PROGRAM_PIPELINE_BINDING: u32 = 0x825A;
3643
3644pub const PROGRAM_POINT_SIZE: u32 = 0x8642;
3645
3646pub const PROGRAM_SEPARABLE: u32 = 0x8258;
3647
3648pub const PROVOKING_VERTEX: u32 = 0x8E4F;
3649
3650pub const PROXY_TEXTURE_1D: u32 = 0x8063;
3651
3652pub const PROXY_TEXTURE_1D_ARRAY: u32 = 0x8C19;
3653
3654pub const PROXY_TEXTURE_2D: u32 = 0x8064;
3655
3656pub const PROXY_TEXTURE_2D_ARRAY: u32 = 0x8C1B;
3657
3658pub const PROXY_TEXTURE_2D_MULTISAMPLE: u32 = 0x9101;
3659
3660pub const PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY: u32 = 0x9103;
3661
3662pub const PROXY_TEXTURE_3D: u32 = 0x8070;
3663
3664pub const PROXY_TEXTURE_CUBE_MAP: u32 = 0x851B;
3665
3666pub const PROXY_TEXTURE_CUBE_MAP_ARRAY: u32 = 0x900B;
3667
3668pub const PROXY_TEXTURE_RECTANGLE: u32 = 0x84F7;
3669
3670pub const QUADS: u32 = 0x0007;
3671
3672pub const QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION: u32 = 0x8E4C;
3673
3674pub const QUERY: u32 = 0x82E3;
3675
3676pub const QUERY_BUFFER: u32 = 0x9192;
3677
3678pub const QUERY_BUFFER_BARRIER_BIT: u32 = 0x00008000;
3679
3680pub const QUERY_BUFFER_BINDING: u32 = 0x9193;
3681
3682pub const QUERY_BY_REGION_NO_WAIT: u32 = 0x8E16;
3683
3684pub const QUERY_BY_REGION_NO_WAIT_INVERTED: u32 = 0x8E1A;
3685
3686pub const QUERY_BY_REGION_WAIT: u32 = 0x8E15;
3687
3688pub const QUERY_BY_REGION_WAIT_INVERTED: u32 = 0x8E19;
3689
3690pub const QUERY_COUNTER_BITS: u32 = 0x8864;
3691
3692pub const QUERY_NO_WAIT: u32 = 0x8E14;
3693
3694pub const QUERY_NO_WAIT_INVERTED: u32 = 0x8E18;
3695
3696pub const QUERY_RESULT: u32 = 0x8866;
3697
3698pub const QUERY_RESULT_AVAILABLE: u32 = 0x8867;
3699
3700pub const QUERY_RESULT_NO_WAIT: u32 = 0x9194;
3701
3702pub const QUERY_TARGET: u32 = 0x82EA;
3703
3704pub const QUERY_WAIT: u32 = 0x8E13;
3705
3706pub const QUERY_WAIT_INVERTED: u32 = 0x8E17;
3707
3708pub const R11F_G11F_B10F: u32 = 0x8C3A;
3709
3710pub const R16: u32 = 0x822A;
3711
3712pub const R16F: u32 = 0x822D;
3713
3714pub const R16I: u32 = 0x8233;
3715
3716pub const R16UI: u32 = 0x8234;
3717
3718pub const R16_SNORM: u32 = 0x8F98;
3719
3720pub const R32F: u32 = 0x822E;
3721
3722pub const R32I: u32 = 0x8235;
3723
3724pub const R32UI: u32 = 0x8236;
3725
3726pub const R3_G3_B2: u32 = 0x2A10;
3727
3728pub const R8: u32 = 0x8229;
3729
3730pub const R8I: u32 = 0x8231;
3731
3732pub const R8UI: u32 = 0x8232;
3733
3734pub const R8_SNORM: u32 = 0x8F94;
3735
3736pub const RASTERIZER_DISCARD: u32 = 0x8C89;
3737
3738pub const READ_BUFFER: u32 = 0x0C02;
3739
3740pub const READ_FRAMEBUFFER: u32 = 0x8CA8;
3741
3742pub const READ_FRAMEBUFFER_BINDING: u32 = 0x8CAA;
3743
3744pub const READ_ONLY: u32 = 0x88B8;
3745
3746pub const READ_PIXELS: u32 = 0x828C;
3747
3748pub const READ_PIXELS_FORMAT: u32 = 0x828D;
3749
3750pub const READ_PIXELS_TYPE: u32 = 0x828E;
3751
3752pub const READ_WRITE: u32 = 0x88BA;
3753
3754pub const RED: u32 = 0x1903;
3755
3756pub const RED_BITS: u32 = 0x0D52;
3757
3758pub const RED_INTEGER: u32 = 0x8D94;
3759
3760pub const REFERENCED_BY_COMPUTE_SHADER: u32 = 0x930B;
3761
3762pub const REFERENCED_BY_FRAGMENT_SHADER: u32 = 0x930A;
3763
3764pub const REFERENCED_BY_GEOMETRY_SHADER: u32 = 0x9309;
3765
3766pub const REFERENCED_BY_TESS_CONTROL_SHADER: u32 = 0x9307;
3767
3768pub const REFERENCED_BY_TESS_EVALUATION_SHADER: u32 = 0x9308;
3769
3770pub const REFERENCED_BY_VERTEX_SHADER: u32 = 0x9306;
3771
3772pub const RENDERBUFFER: u32 = 0x8D41;
3773
3774pub const RENDERBUFFER_ALPHA_SIZE: u32 = 0x8D53;
3775
3776pub const RENDERBUFFER_BINDING: u32 = 0x8CA7;
3777
3778pub const RENDERBUFFER_BLUE_SIZE: u32 = 0x8D52;
3779
3780pub const RENDERBUFFER_DEPTH_SIZE: u32 = 0x8D54;
3781
3782pub const RENDERBUFFER_GREEN_SIZE: u32 = 0x8D51;
3783
3784pub const RENDERBUFFER_HEIGHT: u32 = 0x8D43;
3785
3786pub const RENDERBUFFER_INTERNAL_FORMAT: u32 = 0x8D44;
3787
3788pub const RENDERBUFFER_RED_SIZE: u32 = 0x8D50;
3789
3790pub const RENDERBUFFER_SAMPLES: u32 = 0x8CAB;
3791
3792pub const RENDERBUFFER_STENCIL_SIZE: u32 = 0x8D55;
3793
3794pub const RENDERBUFFER_WIDTH: u32 = 0x8D42;
3795
3796pub const RENDERER: u32 = 0x1F01;
3797
3798pub const REPEAT: u32 = 0x2901;
3799
3800pub const REPLACE: u32 = 0x1E01;
3801
3802pub const RESET_NOTIFICATION_STRATEGY: u32 = 0x8256;
3803
3804pub const RG: u32 = 0x8227;
3805
3806pub const RG16: u32 = 0x822C;
3807
3808pub const RG16F: u32 = 0x822F;
3809
3810pub const RG16I: u32 = 0x8239;
3811
3812pub const RG16UI: u32 = 0x823A;
3813
3814pub const RG16_SNORM: u32 = 0x8F99;
3815
3816pub const RG32F: u32 = 0x8230;
3817
3818pub const RG32I: u32 = 0x823B;
3819
3820pub const RG32UI: u32 = 0x823C;
3821
3822pub const RG8: u32 = 0x822B;
3823
3824pub const RG8I: u32 = 0x8237;
3825
3826pub const RG8UI: u32 = 0x8238;
3827
3828pub const RG8_SNORM: u32 = 0x8F95;
3829
3830pub const RGB: u32 = 0x1907;
3831
3832pub const RGB10: u32 = 0x8052;
3833
3834pub const RGB10_A2: u32 = 0x8059;
3835
3836pub const RGB10_A2UI: u32 = 0x906F;
3837
3838pub const RGB12: u32 = 0x8053;
3839
3840pub const RGB16: u32 = 0x8054;
3841
3842pub const RGB16F: u32 = 0x881B;
3843
3844pub const RGB16I: u32 = 0x8D89;
3845
3846pub const RGB16UI: u32 = 0x8D77;
3847
3848pub const RGB16_SNORM: u32 = 0x8F9A;
3849
3850pub const RGB32F: u32 = 0x8815;
3851
3852pub const RGB32I: u32 = 0x8D83;
3853
3854pub const RGB32UI: u32 = 0x8D71;
3855
3856pub const RGB4: u32 = 0x804F;
3857
3858pub const RGB5: u32 = 0x8050;
3859
3860pub const RGB565: u32 = 0x8D62;
3861
3862pub const RGB5_A1: u32 = 0x8057;
3863
3864pub const RGB8: u32 = 0x8051;
3865
3866pub const RGB8I: u32 = 0x8D8F;
3867
3868pub const RGB8UI: u32 = 0x8D7D;
3869
3870pub const RGB8_SNORM: u32 = 0x8F96;
3871
3872pub const RGB9_E5: u32 = 0x8C3D;
3873
3874pub const RGBA: u32 = 0x1908;
3875
3876pub const RGBA12: u32 = 0x805A;
3877
3878pub const RGBA16: u32 = 0x805B;
3879
3880pub const RGBA16F: u32 = 0x881A;
3881
3882pub const RGBA16I: u32 = 0x8D88;
3883
3884pub const RGBA16UI: u32 = 0x8D76;
3885
3886pub const RGBA16_SNORM: u32 = 0x8F9B;
3887
3888pub const RGBA2: u32 = 0x8055;
3889
3890pub const RGBA32F: u32 = 0x8814;
3891
3892pub const RGBA32I: u32 = 0x8D82;
3893
3894pub const RGBA32UI: u32 = 0x8D70;
3895
3896pub const RGBA4: u32 = 0x8056;
3897
3898pub const RGBA8: u32 = 0x8058;
3899
3900pub const RGBA8I: u32 = 0x8D8E;
3901
3902pub const RGBA8UI: u32 = 0x8D7C;
3903
3904pub const RGBA8_SNORM: u32 = 0x8F97;
3905
3906pub const RGBA_INTEGER: u32 = 0x8D99;
3907
3908pub const RGB_INTEGER: u32 = 0x8D98;
3909
3910pub const RG_INTEGER: u32 = 0x8228;
3911
3912pub const RIGHT: u32 = 0x0407;
3913
3914pub const SAMPLER: u32 = 0x82E6;
3915
3916pub const SAMPLER_1D: u32 = 0x8B5D;
3917
3918pub const SAMPLER_1D_ARRAY: u32 = 0x8DC0;
3919
3920pub const SAMPLER_1D_ARRAY_SHADOW: u32 = 0x8DC3;
3921
3922pub const SAMPLER_1D_SHADOW: u32 = 0x8B61;
3923
3924pub const SAMPLER_2D: u32 = 0x8B5E;
3925
3926pub const SAMPLER_2D_ARRAY: u32 = 0x8DC1;
3927
3928pub const SAMPLER_2D_ARRAY_SHADOW: u32 = 0x8DC4;
3929
3930pub const SAMPLER_2D_MULTISAMPLE: u32 = 0x9108;
3931
3932pub const SAMPLER_2D_MULTISAMPLE_ARRAY: u32 = 0x910B;
3933
3934pub const SAMPLER_2D_RECT: u32 = 0x8B63;
3935
3936pub const SAMPLER_2D_RECT_SHADOW: u32 = 0x8B64;
3937
3938pub const SAMPLER_2D_SHADOW: u32 = 0x8B62;
3939
3940pub const SAMPLER_3D: u32 = 0x8B5F;
3941
3942pub const SAMPLER_BINDING: u32 = 0x8919;
3943
3944pub const SAMPLER_BUFFER: u32 = 0x8DC2;
3945
3946pub const SAMPLER_CUBE: u32 = 0x8B60;
3947
3948pub const SAMPLER_CUBE_MAP_ARRAY: u32 = 0x900C;
3949
3950pub const SAMPLER_CUBE_MAP_ARRAY_SHADOW: u32 = 0x900D;
3951
3952pub const SAMPLER_CUBE_SHADOW: u32 = 0x8DC5;
3953
3954pub const SAMPLES: u32 = 0x80A9;
3955
3956pub const SAMPLES_PASSED: u32 = 0x8914;
3957
3958pub const SAMPLE_ALPHA_TO_COVERAGE: u32 = 0x809E;
3959
3960pub const SAMPLE_ALPHA_TO_ONE: u32 = 0x809F;
3961
3962pub const SAMPLE_BUFFERS: u32 = 0x80A8;
3963
3964pub const SAMPLE_COVERAGE: u32 = 0x80A0;
3965
3966pub const SAMPLE_COVERAGE_INVERT: u32 = 0x80AB;
3967
3968pub const SAMPLE_COVERAGE_VALUE: u32 = 0x80AA;
3969
3970pub const SAMPLE_MASK: u32 = 0x8E51;
3971
3972pub const SAMPLE_MASK_VALUE: u32 = 0x8E52;
3973
3974pub const SAMPLE_POSITION: u32 = 0x8E50;
3975
3976pub const SAMPLE_SHADING: u32 = 0x8C36;
3977
3978pub const SCISSOR_BOX: u32 = 0x0C10;
3979
3980pub const SCISSOR_TEST: u32 = 0x0C11;
3981
3982pub const SEPARATE_ATTRIBS: u32 = 0x8C8D;
3983
3984pub const SET: u32 = 0x150F;
3985
3986pub const SHADER: u32 = 0x82E1;
3987
3988pub const SHADER_BINARY_FORMATS: u32 = 0x8DF8;
3989
3990pub const SHADER_BINARY_FORMAT_SPIR_V: u32 = 0x9551;
3991
3992pub const SHADER_COMPILER: u32 = 0x8DFA;
3993
3994pub const SHADER_IMAGE_ACCESS_BARRIER_BIT: u32 = 0x00000020;
3995
3996pub const SHADER_IMAGE_ATOMIC: u32 = 0x82A6;
3997
3998pub const SHADER_IMAGE_LOAD: u32 = 0x82A4;
3999
4000pub const SHADER_IMAGE_STORE: u32 = 0x82A5;
4001
4002pub const SHADER_SOURCE_LENGTH: u32 = 0x8B88;
4003
4004pub const SHADER_STORAGE_BARRIER_BIT: u32 = 0x00002000;
4005
4006pub const SHADER_STORAGE_BLOCK: u32 = 0x92E6;
4007
4008pub const SHADER_STORAGE_BUFFER: u32 = 0x90D2;
4009
4010pub const SHADER_STORAGE_BUFFER_BINDING: u32 = 0x90D3;
4011
4012pub const SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT: u32 = 0x90DF;
4013
4014pub const SHADER_STORAGE_BUFFER_SIZE: u32 = 0x90D5;
4015
4016pub const SHADER_STORAGE_BUFFER_START: u32 = 0x90D4;
4017
4018pub const SHADER_TYPE: u32 = 0x8B4F;
4019
4020pub const SHADING_LANGUAGE_VERSION: u32 = 0x8B8C;
4021
4022pub const SHORT: u32 = 0x1402;
4023
4024pub const SIGNALED: u32 = 0x9119;
4025
4026pub const SIGNED_NORMALIZED: u32 = 0x8F9C;
4027
4028pub const SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST: u32 = 0x82AC;
4029
4030pub const SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE: u32 = 0x82AE;
4031
4032pub const SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST: u32 = 0x82AD;
4033
4034pub const SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE: u32 = 0x82AF;
4035
4036pub const SMOOTH_LINE_WIDTH_GRANULARITY: u32 = 0x0B23;
4037
4038pub const SMOOTH_LINE_WIDTH_RANGE: u32 = 0x0B22;
4039
4040pub const SMOOTH_POINT_SIZE_GRANULARITY: u32 = 0x0B13;
4041
4042pub const SMOOTH_POINT_SIZE_RANGE: u32 = 0x0B12;
4043
4044pub const SPIR_V_BINARY: u32 = 0x9552;
4045
4046pub const SPIR_V_EXTENSIONS: u32 = 0x9553;
4047
4048pub const SRC1_ALPHA: u32 = 0x8589;
4049
4050pub const SRC1_COLOR: u32 = 0x88F9;
4051
4052pub const SRC_ALPHA: u32 = 0x0302;
4053
4054pub const SRC_ALPHA_SATURATE: u32 = 0x0308;
4055
4056pub const SRC_COLOR: u32 = 0x0300;
4057
4058pub const SRGB: u32 = 0x8C40;
4059
4060pub const SRGB8: u32 = 0x8C41;
4061
4062pub const SRGB8_ALPHA8: u32 = 0x8C43;
4063
4064pub const SRGB_ALPHA: u32 = 0x8C42;
4065
4066pub const SRGB_READ: u32 = 0x8297;
4067
4068pub const SRGB_WRITE: u32 = 0x8298;
4069
4070pub const STACK_OVERFLOW: u32 = 0x0503;
4071
4072pub const STACK_UNDERFLOW: u32 = 0x0504;
4073
4074pub const STATIC_COPY: u32 = 0x88E6;
4075
4076pub const STATIC_DRAW: u32 = 0x88E4;
4077
4078pub const STATIC_READ: u32 = 0x88E5;
4079
4080pub const STENCIL: u32 = 0x1802;
4081
4082pub const STENCIL_ATTACHMENT: u32 = 0x8D20;
4083
4084pub const STENCIL_BACK_FAIL: u32 = 0x8801;
4085
4086pub const STENCIL_BACK_FUNC: u32 = 0x8800;
4087
4088pub const STENCIL_BACK_PASS_DEPTH_FAIL: u32 = 0x8802;
4089
4090pub const STENCIL_BACK_PASS_DEPTH_PASS: u32 = 0x8803;
4091
4092pub const STENCIL_BACK_REF: u32 = 0x8CA3;
4093
4094pub const STENCIL_BACK_VALUE_MASK: u32 = 0x8CA4;
4095
4096pub const STENCIL_BACK_WRITEMASK: u32 = 0x8CA5;
4097
4098pub const STENCIL_BITS: u32 = 0x0D57;
4099
4100pub const STENCIL_BUFFER_BIT: u32 = 0x00000400;
4101
4102pub const STENCIL_CLEAR_VALUE: u32 = 0x0B91;
4103
4104pub const STENCIL_COMPONENTS: u32 = 0x8285;
4105
4106pub const STENCIL_FAIL: u32 = 0x0B94;
4107
4108pub const STENCIL_FUNC: u32 = 0x0B92;
4109
4110pub const STENCIL_INDEX: u32 = 0x1901;
4111
4112pub const STENCIL_INDEX1: u32 = 0x8D46;
4113
4114pub const STENCIL_INDEX16: u32 = 0x8D49;
4115
4116pub const STENCIL_INDEX4: u32 = 0x8D47;
4117
4118pub const STENCIL_INDEX8: u32 = 0x8D48;
4119
4120pub const STENCIL_PASS_DEPTH_FAIL: u32 = 0x0B95;
4121
4122pub const STENCIL_PASS_DEPTH_PASS: u32 = 0x0B96;
4123
4124pub const STENCIL_REF: u32 = 0x0B97;
4125
4126pub const STENCIL_RENDERABLE: u32 = 0x8288;
4127
4128pub const STENCIL_TEST: u32 = 0x0B90;
4129
4130pub const STENCIL_VALUE_MASK: u32 = 0x0B93;
4131
4132pub const STENCIL_WRITEMASK: u32 = 0x0B98;
4133
4134pub const STEREO: u32 = 0x0C33;
4135
4136pub const STREAM_COPY: u32 = 0x88E2;
4137
4138pub const STREAM_DRAW: u32 = 0x88E0;
4139
4140pub const STREAM_READ: u32 = 0x88E1;
4141
4142pub const SUBPIXEL_BITS: u32 = 0x0D50;
4143
4144pub const SYNC_CONDITION: u32 = 0x9113;
4145
4146pub const SYNC_FENCE: u32 = 0x9116;
4147
4148pub const SYNC_FLAGS: u32 = 0x9115;
4149
4150pub const SYNC_FLUSH_COMMANDS_BIT: u32 = 0x00000001;
4151
4152pub const SYNC_GPU_COMMANDS_COMPLETE: u32 = 0x9117;
4153
4154pub const SYNC_STATUS: u32 = 0x9114;
4155
4156pub const TESS_CONTROL_OUTPUT_VERTICES: u32 = 0x8E75;
4157
4158pub const TESS_CONTROL_SHADER: u32 = 0x8E88;
4159
4160pub const TESS_CONTROL_SHADER_BIT: u32 = 0x00000008;
4161
4162pub const TESS_CONTROL_SHADER_PATCHES: u32 = 0x82F1;
4163
4164pub const TESS_CONTROL_SUBROUTINE: u32 = 0x92E9;
4165
4166pub const TESS_CONTROL_SUBROUTINE_UNIFORM: u32 = 0x92EF;
4167
4168pub const TESS_CONTROL_TEXTURE: u32 = 0x829C;
4169
4170pub const TESS_EVALUATION_SHADER: u32 = 0x8E87;
4171
4172pub const TESS_EVALUATION_SHADER_BIT: u32 = 0x00000010;
4173
4174pub const TESS_EVALUATION_SHADER_INVOCATIONS: u32 = 0x82F2;
4175
4176pub const TESS_EVALUATION_SUBROUTINE: u32 = 0x92EA;
4177
4178pub const TESS_EVALUATION_SUBROUTINE_UNIFORM: u32 = 0x92F0;
4179
4180pub const TESS_EVALUATION_TEXTURE: u32 = 0x829D;
4181
4182pub const TESS_GEN_MODE: u32 = 0x8E76;
4183
4184pub const TESS_GEN_POINT_MODE: u32 = 0x8E79;
4185
4186pub const TESS_GEN_SPACING: u32 = 0x8E77;
4187
4188pub const TESS_GEN_VERTEX_ORDER: u32 = 0x8E78;
4189
4190pub const TEXTURE: u32 = 0x1702;
4191
4192pub const TEXTURE0: u32 = 0x84C0;
4193
4194pub const TEXTURE1: u32 = 0x84C1;
4195
4196pub const TEXTURE10: u32 = 0x84CA;
4197
4198pub const TEXTURE11: u32 = 0x84CB;
4199
4200pub const TEXTURE12: u32 = 0x84CC;
4201
4202pub const TEXTURE13: u32 = 0x84CD;
4203
4204pub const TEXTURE14: u32 = 0x84CE;
4205
4206pub const TEXTURE15: u32 = 0x84CF;
4207
4208pub const TEXTURE16: u32 = 0x84D0;
4209
4210pub const TEXTURE17: u32 = 0x84D1;
4211
4212pub const TEXTURE18: u32 = 0x84D2;
4213
4214pub const TEXTURE19: u32 = 0x84D3;
4215
4216pub const TEXTURE2: u32 = 0x84C2;
4217
4218pub const TEXTURE20: u32 = 0x84D4;
4219
4220pub const TEXTURE21: u32 = 0x84D5;
4221
4222pub const TEXTURE22: u32 = 0x84D6;
4223
4224pub const TEXTURE23: u32 = 0x84D7;
4225
4226pub const TEXTURE24: u32 = 0x84D8;
4227
4228pub const TEXTURE25: u32 = 0x84D9;
4229
4230pub const TEXTURE26: u32 = 0x84DA;
4231
4232pub const TEXTURE27: u32 = 0x84DB;
4233
4234pub const TEXTURE28: u32 = 0x84DC;
4235
4236pub const TEXTURE29: u32 = 0x84DD;
4237
4238pub const TEXTURE3: u32 = 0x84C3;
4239
4240pub const TEXTURE30: u32 = 0x84DE;
4241
4242pub const TEXTURE31: u32 = 0x84DF;
4243
4244pub const TEXTURE4: u32 = 0x84C4;
4245
4246pub const TEXTURE5: u32 = 0x84C5;
4247
4248pub const TEXTURE6: u32 = 0x84C6;
4249
4250pub const TEXTURE7: u32 = 0x84C7;
4251
4252pub const TEXTURE8: u32 = 0x84C8;
4253
4254pub const TEXTURE9: u32 = 0x84C9;
4255
4256pub const TEXTURE_1D: u32 = 0x0DE0;
4257
4258pub const TEXTURE_1D_ARRAY: u32 = 0x8C18;
4259
4260pub const TEXTURE_2D: u32 = 0x0DE1;
4261
4262pub const TEXTURE_2D_ARRAY: u32 = 0x8C1A;
4263
4264pub const TEXTURE_2D_MULTISAMPLE: u32 = 0x9100;
4265
4266pub const TEXTURE_2D_MULTISAMPLE_ARRAY: u32 = 0x9102;
4267
4268pub const TEXTURE_3D: u32 = 0x806F;
4269
4270pub const TEXTURE_ALPHA_SIZE: u32 = 0x805F;
4271
4272pub const TEXTURE_ALPHA_TYPE: u32 = 0x8C13;
4273
4274pub const TEXTURE_BASE_LEVEL: u32 = 0x813C;
4275
4276pub const TEXTURE_BINDING_1D: u32 = 0x8068;
4277
4278pub const TEXTURE_BINDING_1D_ARRAY: u32 = 0x8C1C;
4279
4280pub const TEXTURE_BINDING_2D: u32 = 0x8069;
4281
4282pub const TEXTURE_BINDING_2D_ARRAY: u32 = 0x8C1D;
4283
4284pub const TEXTURE_BINDING_2D_MULTISAMPLE: u32 = 0x9104;
4285
4286pub const TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY: u32 = 0x9105;
4287
4288pub const TEXTURE_BINDING_3D: u32 = 0x806A;
4289
4290pub const TEXTURE_BINDING_BUFFER: u32 = 0x8C2C;
4291
4292pub const TEXTURE_BINDING_CUBE_MAP: u32 = 0x8514;
4293
4294pub const TEXTURE_BINDING_CUBE_MAP_ARRAY: u32 = 0x900A;
4295
4296pub const TEXTURE_BINDING_RECTANGLE: u32 = 0x84F6;
4297
4298pub const TEXTURE_BLUE_SIZE: u32 = 0x805E;
4299
4300pub const TEXTURE_BLUE_TYPE: u32 = 0x8C12;
4301
4302pub const TEXTURE_BORDER_COLOR: u32 = 0x1004;
4303
4304pub const TEXTURE_BUFFER: u32 = 0x8C2A;
4305
4306pub const TEXTURE_BUFFER_BINDING: u32 = 0x8C2A;
4307
4308pub const TEXTURE_BUFFER_DATA_STORE_BINDING: u32 = 0x8C2D;
4309
4310pub const TEXTURE_BUFFER_OFFSET: u32 = 0x919D;
4311
4312pub const TEXTURE_BUFFER_OFFSET_ALIGNMENT: u32 = 0x919F;
4313
4314pub const TEXTURE_BUFFER_SIZE: u32 = 0x919E;
4315
4316pub const TEXTURE_COMPARE_FUNC: u32 = 0x884D;
4317
4318pub const TEXTURE_COMPARE_MODE: u32 = 0x884C;
4319
4320pub const TEXTURE_COMPRESSED: u32 = 0x86A1;
4321
4322pub const TEXTURE_COMPRESSED_BLOCK_HEIGHT: u32 = 0x82B2;
4323
4324pub const TEXTURE_COMPRESSED_BLOCK_SIZE: u32 = 0x82B3;
4325
4326pub const TEXTURE_COMPRESSED_BLOCK_WIDTH: u32 = 0x82B1;
4327
4328pub const TEXTURE_COMPRESSED_IMAGE_SIZE: u32 = 0x86A0;
4329
4330pub const TEXTURE_COMPRESSION_HINT: u32 = 0x84EF;
4331
4332pub const TEXTURE_CUBE_MAP: u32 = 0x8513;
4333
4334pub const TEXTURE_CUBE_MAP_ARRAY: u32 = 0x9009;
4335
4336pub const TEXTURE_CUBE_MAP_NEGATIVE_X: u32 = 0x8516;
4337
4338pub const TEXTURE_CUBE_MAP_NEGATIVE_Y: u32 = 0x8518;
4339
4340pub const TEXTURE_CUBE_MAP_NEGATIVE_Z: u32 = 0x851A;
4341
4342pub const TEXTURE_CUBE_MAP_POSITIVE_X: u32 = 0x8515;
4343
4344pub const TEXTURE_CUBE_MAP_POSITIVE_Y: u32 = 0x8517;
4345
4346pub const TEXTURE_CUBE_MAP_POSITIVE_Z: u32 = 0x8519;
4347
4348pub const TEXTURE_CUBE_MAP_SEAMLESS: u32 = 0x884F;
4349
4350pub const TEXTURE_DEPTH: u32 = 0x8071;
4351
4352pub const TEXTURE_DEPTH_SIZE: u32 = 0x884A;
4353
4354pub const TEXTURE_DEPTH_TYPE: u32 = 0x8C16;
4355
4356pub const TEXTURE_FETCH_BARRIER_BIT: u32 = 0x00000008;
4357
4358pub const TEXTURE_FIXED_SAMPLE_LOCATIONS: u32 = 0x9107;
4359
4360pub const TEXTURE_GATHER: u32 = 0x82A2;
4361
4362pub const TEXTURE_GATHER_SHADOW: u32 = 0x82A3;
4363
4364pub const TEXTURE_GREEN_SIZE: u32 = 0x805D;
4365
4366pub const TEXTURE_GREEN_TYPE: u32 = 0x8C11;
4367
4368pub const TEXTURE_HEIGHT: u32 = 0x1001;
4369
4370pub const TEXTURE_IMAGE_FORMAT: u32 = 0x828F;
4371
4372pub const TEXTURE_IMAGE_TYPE: u32 = 0x8290;
4373
4374pub const TEXTURE_IMMUTABLE_FORMAT: u32 = 0x912F;
4375
4376pub const TEXTURE_IMMUTABLE_LEVELS: u32 = 0x82DF;
4377
4378pub const TEXTURE_INTERNAL_FORMAT: u32 = 0x1003;
4379
4380pub const TEXTURE_LOD_BIAS: u32 = 0x8501;
4381
4382pub const TEXTURE_MAG_FILTER: u32 = 0x2800;
4383
4384pub const TEXTURE_MAX_ANISOTROPY: u32 = 0x84FE;
4385
4386pub const TEXTURE_MAX_ANISOTROPY_EXT: u32 = 0x84FE;
4387
4388pub const TEXTURE_MAX_LEVEL: u32 = 0x813D;
4389
4390pub const TEXTURE_MAX_LOD: u32 = 0x813B;
4391
4392pub const TEXTURE_MIN_FILTER: u32 = 0x2801;
4393
4394pub const TEXTURE_MIN_LOD: u32 = 0x813A;
4395
4396pub const TEXTURE_RECTANGLE: u32 = 0x84F5;
4397
4398pub const TEXTURE_RED_SIZE: u32 = 0x805C;
4399
4400pub const TEXTURE_RED_TYPE: u32 = 0x8C10;
4401
4402pub const TEXTURE_SAMPLES: u32 = 0x9106;
4403
4404pub const TEXTURE_SHADOW: u32 = 0x82A1;
4405
4406pub const TEXTURE_SHARED_SIZE: u32 = 0x8C3F;
4407
4408pub const TEXTURE_STENCIL_SIZE: u32 = 0x88F1;
4409
4410pub const TEXTURE_SWIZZLE_A: u32 = 0x8E45;
4411
4412pub const TEXTURE_SWIZZLE_B: u32 = 0x8E44;
4413
4414pub const TEXTURE_SWIZZLE_G: u32 = 0x8E43;
4415
4416pub const TEXTURE_SWIZZLE_R: u32 = 0x8E42;
4417
4418pub const TEXTURE_SWIZZLE_RGBA: u32 = 0x8E46;
4419
4420pub const TEXTURE_TARGET: u32 = 0x1006;
4421
4422pub const TEXTURE_UPDATE_BARRIER_BIT: u32 = 0x00000100;
4423
4424pub const TEXTURE_VIEW: u32 = 0x82B5;
4425
4426pub const TEXTURE_VIEW_MIN_LAYER: u32 = 0x82DD;
4427
4428pub const TEXTURE_VIEW_MIN_LEVEL: u32 = 0x82DB;
4429
4430pub const TEXTURE_VIEW_NUM_LAYERS: u32 = 0x82DE;
4431
4432pub const TEXTURE_VIEW_NUM_LEVELS: u32 = 0x82DC;
4433
4434pub const TEXTURE_WIDTH: u32 = 0x1000;
4435
4436pub const TEXTURE_WRAP_R: u32 = 0x8072;
4437
4438pub const TEXTURE_WRAP_S: u32 = 0x2802;
4439
4440pub const TEXTURE_WRAP_T: u32 = 0x2803;
4441
4442pub const TIMEOUT_EXPIRED: u32 = 0x911B;
4443
4444pub const TIMEOUT_IGNORED: u64 = 0xFFFFFFFFFFFFFFFF;
4445
4446pub const TIMESTAMP: u32 = 0x8E28;
4447
4448pub const TIME_ELAPSED: u32 = 0x88BF;
4449
4450pub const TOP_LEVEL_ARRAY_SIZE: u32 = 0x930C;
4451
4452pub const TOP_LEVEL_ARRAY_STRIDE: u32 = 0x930D;
4453
4454pub const TRANSFORM_FEEDBACK: u32 = 0x8E22;
4455
4456pub const TRANSFORM_FEEDBACK_ACTIVE: u32 = 0x8E24;
4457
4458pub const TRANSFORM_FEEDBACK_BARRIER_BIT: u32 = 0x00000800;
4459
4460pub const TRANSFORM_FEEDBACK_BINDING: u32 = 0x8E25;
4461
4462pub const TRANSFORM_FEEDBACK_BUFFER: u32 = 0x8C8E;
4463
4464pub const TRANSFORM_FEEDBACK_BUFFER_ACTIVE: u32 = 0x8E24;
4465
4466pub const TRANSFORM_FEEDBACK_BUFFER_BINDING: u32 = 0x8C8F;
4467
4468pub const TRANSFORM_FEEDBACK_BUFFER_INDEX: u32 = 0x934B;
4469
4470pub const TRANSFORM_FEEDBACK_BUFFER_MODE: u32 = 0x8C7F;
4471
4472pub const TRANSFORM_FEEDBACK_BUFFER_PAUSED: u32 = 0x8E23;
4473
4474pub const TRANSFORM_FEEDBACK_BUFFER_SIZE: u32 = 0x8C85;
4475
4476pub const TRANSFORM_FEEDBACK_BUFFER_START: u32 = 0x8C84;
4477
4478pub const TRANSFORM_FEEDBACK_BUFFER_STRIDE: u32 = 0x934C;
4479
4480pub const TRANSFORM_FEEDBACK_OVERFLOW: u32 = 0x82EC;
4481
4482pub const TRANSFORM_FEEDBACK_PAUSED: u32 = 0x8E23;
4483
4484pub const TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: u32 = 0x8C88;
4485
4486pub const TRANSFORM_FEEDBACK_STREAM_OVERFLOW: u32 = 0x82ED;
4487
4488pub const TRANSFORM_FEEDBACK_VARYING: u32 = 0x92F4;
4489
4490pub const TRANSFORM_FEEDBACK_VARYINGS: u32 = 0x8C83;
4491
4492pub const TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: u32 = 0x8C76;
4493
4494pub const TRIANGLES: u32 = 0x0004;
4495
4496pub const TRIANGLES_ADJACENCY: u32 = 0x000C;
4497
4498pub const TRIANGLE_FAN: u32 = 0x0006;
4499
4500pub const TRIANGLE_STRIP: u32 = 0x0005;
4501
4502pub const TRIANGLE_STRIP_ADJACENCY: u32 = 0x000D;
4503
4504pub const TRUE: u8 = 1;
4505
4506pub const TYPE: u32 = 0x92FA;
4507
4508pub const UNDEFINED_VERTEX: u32 = 0x8260;
4509
4510pub const UNIFORM: u32 = 0x92E1;
4511
4512pub const UNIFORM_ARRAY_STRIDE: u32 = 0x8A3C;
4513
4514pub const UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX: u32 = 0x92DA;
4515
4516pub const UNIFORM_BARRIER_BIT: u32 = 0x00000004;
4517
4518pub const UNIFORM_BLOCK: u32 = 0x92E2;
4519
4520pub const UNIFORM_BLOCK_ACTIVE_UNIFORMS: u32 = 0x8A42;
4521
4522pub const UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: u32 = 0x8A43;
4523
4524pub const UNIFORM_BLOCK_BINDING: u32 = 0x8A3F;
4525
4526pub const UNIFORM_BLOCK_DATA_SIZE: u32 = 0x8A40;
4527
4528pub const UNIFORM_BLOCK_INDEX: u32 = 0x8A3A;
4529
4530pub const UNIFORM_BLOCK_NAME_LENGTH: u32 = 0x8A41;
4531
4532pub const UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER: u32 = 0x90EC;
4533
4534pub const UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: u32 = 0x8A46;
4535
4536pub const UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER: u32 = 0x8A45;
4537
4538pub const UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER: u32 = 0x84F0;
4539
4540pub const UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER: u32 = 0x84F1;
4541
4542pub const UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: u32 = 0x8A44;
4543
4544pub const UNIFORM_BUFFER: u32 = 0x8A11;
4545
4546pub const UNIFORM_BUFFER_BINDING: u32 = 0x8A28;
4547
4548pub const UNIFORM_BUFFER_OFFSET_ALIGNMENT: u32 = 0x8A34;
4549
4550pub const UNIFORM_BUFFER_SIZE: u32 = 0x8A2A;
4551
4552pub const UNIFORM_BUFFER_START: u32 = 0x8A29;
4553
4554pub const UNIFORM_IS_ROW_MAJOR: u32 = 0x8A3E;
4555
4556pub const UNIFORM_MATRIX_STRIDE: u32 = 0x8A3D;
4557
4558pub const UNIFORM_NAME_LENGTH: u32 = 0x8A39;
4559
4560pub const UNIFORM_OFFSET: u32 = 0x8A3B;
4561
4562pub const UNIFORM_SIZE: u32 = 0x8A38;
4563
4564pub const UNIFORM_TYPE: u32 = 0x8A37;
4565
4566pub const UNKNOWN_CONTEXT_RESET: u32 = 0x8255;
4567
4568pub const UNPACK_ALIGNMENT: u32 = 0x0CF5;
4569
4570pub const UNPACK_COMPRESSED_BLOCK_DEPTH: u32 = 0x9129;
4571
4572pub const UNPACK_COMPRESSED_BLOCK_HEIGHT: u32 = 0x9128;
4573
4574pub const UNPACK_COMPRESSED_BLOCK_SIZE: u32 = 0x912A;
4575
4576pub const UNPACK_COMPRESSED_BLOCK_WIDTH: u32 = 0x9127;
4577
4578pub const UNPACK_IMAGE_HEIGHT: u32 = 0x806E;
4579
4580pub const UNPACK_LSB_FIRST: u32 = 0x0CF1;
4581
4582pub const UNPACK_ROW_LENGTH: u32 = 0x0CF2;
4583
4584pub const UNPACK_SKIP_IMAGES: u32 = 0x806D;
4585
4586pub const UNPACK_SKIP_PIXELS: u32 = 0x0CF4;
4587
4588pub const UNPACK_SKIP_ROWS: u32 = 0x0CF3;
4589
4590pub const UNPACK_SWAP_BYTES: u32 = 0x0CF0;
4591
4592pub const UNSIGNALED: u32 = 0x9118;
4593
4594pub const UNSIGNED_BYTE: u32 = 0x1401;
4595
4596pub const UNSIGNED_BYTE_2_3_3_REV: u32 = 0x8362;
4597
4598pub const UNSIGNED_BYTE_3_3_2: u32 = 0x8032;
4599
4600pub const UNSIGNED_INT: u32 = 0x1405;
4601
4602pub const UNSIGNED_INT_10F_11F_11F_REV: u32 = 0x8C3B;
4603
4604pub const UNSIGNED_INT_10_10_10_2: u32 = 0x8036;
4605
4606pub const UNSIGNED_INT_24_8: u32 = 0x84FA;
4607
4608pub const UNSIGNED_INT_2_10_10_10_REV: u32 = 0x8368;
4609
4610pub const UNSIGNED_INT_5_9_9_9_REV: u32 = 0x8C3E;
4611
4612pub const UNSIGNED_INT_8_8_8_8: u32 = 0x8035;
4613
4614pub const UNSIGNED_INT_8_8_8_8_REV: u32 = 0x8367;
4615
4616pub const UNSIGNED_INT_ATOMIC_COUNTER: u32 = 0x92DB;
4617
4618pub const UNSIGNED_INT_IMAGE_1D: u32 = 0x9062;
4619
4620pub const UNSIGNED_INT_IMAGE_1D_ARRAY: u32 = 0x9068;
4621
4622pub const UNSIGNED_INT_IMAGE_2D: u32 = 0x9063;
4623
4624pub const UNSIGNED_INT_IMAGE_2D_ARRAY: u32 = 0x9069;
4625
4626pub const UNSIGNED_INT_IMAGE_2D_MULTISAMPLE: u32 = 0x906B;
4627
4628pub const UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY: u32 = 0x906C;
4629
4630pub const UNSIGNED_INT_IMAGE_2D_RECT: u32 = 0x9065;
4631
4632pub const UNSIGNED_INT_IMAGE_3D: u32 = 0x9064;
4633
4634pub const UNSIGNED_INT_IMAGE_BUFFER: u32 = 0x9067;
4635
4636pub const UNSIGNED_INT_IMAGE_CUBE: u32 = 0x9066;
4637
4638pub const UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY: u32 = 0x906A;
4639
4640pub const UNSIGNED_INT_SAMPLER_1D: u32 = 0x8DD1;
4641
4642pub const UNSIGNED_INT_SAMPLER_1D_ARRAY: u32 = 0x8DD6;
4643
4644pub const UNSIGNED_INT_SAMPLER_2D: u32 = 0x8DD2;
4645
4646pub const UNSIGNED_INT_SAMPLER_2D_ARRAY: u32 = 0x8DD7;
4647
4648pub const UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE: u32 = 0x910A;
4649
4650pub const UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: u32 = 0x910D;
4651
4652pub const UNSIGNED_INT_SAMPLER_2D_RECT: u32 = 0x8DD5;
4653
4654pub const UNSIGNED_INT_SAMPLER_3D: u32 = 0x8DD3;
4655
4656pub const UNSIGNED_INT_SAMPLER_BUFFER: u32 = 0x8DD8;
4657
4658pub const UNSIGNED_INT_SAMPLER_CUBE: u32 = 0x8DD4;
4659
4660pub const UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY: u32 = 0x900F;
4661
4662pub const UNSIGNED_INT_VEC2: u32 = 0x8DC6;
4663
4664pub const UNSIGNED_INT_VEC3: u32 = 0x8DC7;
4665
4666pub const UNSIGNED_INT_VEC4: u32 = 0x8DC8;
4667
4668pub const UNSIGNED_NORMALIZED: u32 = 0x8C17;
4669
4670pub const UNSIGNED_SHORT: u32 = 0x1403;
4671
4672pub const UNSIGNED_SHORT_1_5_5_5_REV: u32 = 0x8366;
4673
4674pub const UNSIGNED_SHORT_4_4_4_4: u32 = 0x8033;
4675
4676pub const UNSIGNED_SHORT_4_4_4_4_REV: u32 = 0x8365;
4677
4678pub const UNSIGNED_SHORT_5_5_5_1: u32 = 0x8034;
4679
4680pub const UNSIGNED_SHORT_5_6_5: u32 = 0x8363;
4681
4682pub const UNSIGNED_SHORT_5_6_5_REV: u32 = 0x8364;
4683
4684pub const UPPER_LEFT: u32 = 0x8CA2;
4685
4686pub const VALIDATE_STATUS: u32 = 0x8B83;
4687
4688pub const VENDOR: u32 = 0x1F00;
4689
4690pub const VERSION: u32 = 0x1F02;
4691
4692pub const VERTEX_ARRAY: u32 = 0x8074;
4693
4694pub const VERTEX_ARRAY_BINDING: u32 = 0x85B5;
4695
4696pub const VERTEX_ATTRIB_ARRAY_BARRIER_BIT: u32 = 0x00000001;
4697
4698pub const VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: u32 = 0x889F;
4699
4700pub const VERTEX_ATTRIB_ARRAY_DIVISOR: u32 = 0x88FE;
4701
4702pub const VERTEX_ATTRIB_ARRAY_ENABLED: u32 = 0x8622;
4703
4704pub const VERTEX_ATTRIB_ARRAY_INTEGER: u32 = 0x88FD;
4705
4706pub const VERTEX_ATTRIB_ARRAY_LONG: u32 = 0x874E;
4707
4708pub const VERTEX_ATTRIB_ARRAY_NORMALIZED: u32 = 0x886A;
4709
4710pub const VERTEX_ATTRIB_ARRAY_POINTER: u32 = 0x8645;
4711
4712pub const VERTEX_ATTRIB_ARRAY_SIZE: u32 = 0x8623;
4713
4714pub const VERTEX_ATTRIB_ARRAY_STRIDE: u32 = 0x8624;
4715
4716pub const VERTEX_ATTRIB_ARRAY_TYPE: u32 = 0x8625;
4717
4718pub const VERTEX_ATTRIB_BINDING: u32 = 0x82D4;
4719
4720pub const VERTEX_ATTRIB_RELATIVE_OFFSET: u32 = 0x82D5;
4721
4722pub const VERTEX_BINDING_BUFFER: u32 = 0x8F4F;
4723
4724pub const VERTEX_BINDING_DIVISOR: u32 = 0x82D6;
4725
4726pub const VERTEX_BINDING_OFFSET: u32 = 0x82D7;
4727
4728pub const VERTEX_BINDING_STRIDE: u32 = 0x82D8;
4729
4730pub const VERTEX_PROGRAM_POINT_SIZE: u32 = 0x8642;
4731
4732pub const VERTEX_SHADER: u32 = 0x8B31;
4733
4734pub const VERTEX_SHADER_BIT: u32 = 0x00000001;
4735
4736pub const VERTEX_SHADER_INVOCATIONS: u32 = 0x82F0;
4737
4738pub const VERTEX_SUBROUTINE: u32 = 0x92E8;
4739
4740pub const VERTEX_SUBROUTINE_UNIFORM: u32 = 0x92EE;
4741
4742pub const VERTEX_TEXTURE: u32 = 0x829B;
4743
4744pub const VERTICES_SUBMITTED: u32 = 0x82EE;
4745
4746pub const VIEWPORT: u32 = 0x0BA2;
4747
4748pub const VIEWPORT_BOUNDS_RANGE: u32 = 0x825D;
4749
4750pub const VIEWPORT_INDEX_PROVOKING_VERTEX: u32 = 0x825F;
4751
4752pub const VIEWPORT_SUBPIXEL_BITS: u32 = 0x825C;
4753
4754pub const VIEW_CLASS_128_BITS: u32 = 0x82C4;
4755
4756pub const VIEW_CLASS_16_BITS: u32 = 0x82CA;
4757
4758pub const VIEW_CLASS_24_BITS: u32 = 0x82C9;
4759
4760pub const VIEW_CLASS_32_BITS: u32 = 0x82C8;
4761
4762pub const VIEW_CLASS_48_BITS: u32 = 0x82C7;
4763
4764pub const VIEW_CLASS_64_BITS: u32 = 0x82C6;
4765
4766pub const VIEW_CLASS_8_BITS: u32 = 0x82CB;
4767
4768pub const VIEW_CLASS_96_BITS: u32 = 0x82C5;
4769
4770pub const VIEW_CLASS_BPTC_FLOAT: u32 = 0x82D3;
4771
4772pub const VIEW_CLASS_BPTC_UNORM: u32 = 0x82D2;
4773
4774pub const VIEW_CLASS_RGTC1_RED: u32 = 0x82D0;
4775
4776pub const VIEW_CLASS_RGTC2_RG: u32 = 0x82D1;
4777
4778pub const VIEW_CLASS_S3TC_DXT1_RGB: u32 = 0x82CC;
4779
4780pub const VIEW_CLASS_S3TC_DXT1_RGBA: u32 = 0x82CD;
4781
4782pub const VIEW_CLASS_S3TC_DXT3_RGBA: u32 = 0x82CE;
4783
4784pub const VIEW_CLASS_S3TC_DXT5_RGBA: u32 = 0x82CF;
4785
4786pub const VIEW_COMPATIBILITY_CLASS: u32 = 0x82B6;
4787
4788pub const WAIT_FAILED: u32 = 0x911D;
4789
4790pub const WRITE_ONLY: u32 = 0x88B9;
4791
4792pub const XOR: u32 = 0x1506;
4793
4794pub const ZERO: u32 = 0;
4795
4796pub const ZERO_TO_ONE: u32 = 0x935F;
4797
4798mod __private {
4799 /// Prevents [`HasContext`] from being implemented outside of this crate.
4800 #[doc(hidden)]
4801 pub trait Sealed {}
4802}
4803