1use alloc::sync::Arc;
2use alloc::vec;
3use core::sync::atomic::Ordering;
4
5use arrayvec::ArrayVec;
6use glow::HasContext;
7
8use super::{conv::is_layered_target, lock, Command as C, PrivateCapabilities};
9
10const DEBUG_ID: u32 = 0;
11
12fn extract_marker<'a>(data: &'a [u8], range: &core::ops::Range<u32>) -> &'a str {
13 core::str::from_utf8(&data[range.start as usize..range.end as usize]).unwrap()
14}
15
16fn to_debug_str(s: &str) -> &str {
17 if s.is_empty() {
22 "<empty>"
23 } else {
24 s
25 }
26}
27
28fn get_2d_target(target: u32, array_layer: u32) -> u32 {
29 const CUBEMAP_FACES: [u32; 6] = [
30 glow::TEXTURE_CUBE_MAP_POSITIVE_X,
31 glow::TEXTURE_CUBE_MAP_NEGATIVE_X,
32 glow::TEXTURE_CUBE_MAP_POSITIVE_Y,
33 glow::TEXTURE_CUBE_MAP_NEGATIVE_Y,
34 glow::TEXTURE_CUBE_MAP_POSITIVE_Z,
35 glow::TEXTURE_CUBE_MAP_NEGATIVE_Z,
36 ];
37
38 match target {
39 glow::TEXTURE_2D => target,
40 glow::TEXTURE_CUBE_MAP => CUBEMAP_FACES[array_layer as usize],
41 _ => unreachable!(),
42 }
43}
44
45fn get_z_offset(target: u32, base: &crate::TextureCopyBase) -> u32 {
46 match target {
47 glow::TEXTURE_2D_ARRAY | glow::TEXTURE_CUBE_MAP_ARRAY => base.array_layer,
48 glow::TEXTURE_3D => base.origin.z,
49 _ => unreachable!(),
50 }
51}
52
53impl super::Queue {
54 unsafe fn perform_shader_clear(&self, gl: &glow::Context, draw_buffer: u32, color: [f32; 4]) {
56 let shader_clear = self
57 .shader_clear_program
58 .as_ref()
59 .expect("shader_clear_program should always be set if the workaround is enabled");
60 unsafe { gl.use_program(Some(shader_clear.program)) };
61 unsafe {
62 gl.uniform_4_f32(
63 Some(&shader_clear.color_uniform_location),
64 color[0],
65 color[1],
66 color[2],
67 color[3],
68 )
69 };
70 unsafe { gl.disable(glow::DEPTH_TEST) };
71 unsafe { gl.disable(glow::STENCIL_TEST) };
72 unsafe { gl.disable(glow::SCISSOR_TEST) };
73 unsafe { gl.disable(glow::BLEND) };
74 unsafe { gl.disable(glow::CULL_FACE) };
75 unsafe { gl.draw_buffers(&[glow::COLOR_ATTACHMENT0 + draw_buffer]) };
76 unsafe { gl.draw_arrays(glow::TRIANGLES, 0, 3) };
77
78 let draw_buffer_count = self.draw_buffer_count.load(Ordering::Relaxed);
79 if draw_buffer_count != 0 {
80 let indices = (0..draw_buffer_count as u32)
82 .map(|i| glow::COLOR_ATTACHMENT0 + i)
83 .collect::<ArrayVec<_, { crate::MAX_COLOR_ATTACHMENTS }>>();
84 unsafe { gl.draw_buffers(&indices) };
85 }
86 }
87
88 unsafe fn reset_state(&self, gl: &glow::Context) {
89 unsafe { gl.use_program(None) };
90 unsafe { gl.bind_framebuffer(glow::FRAMEBUFFER, None) };
91 unsafe { gl.disable(glow::DEPTH_TEST) };
92 unsafe { gl.disable(glow::STENCIL_TEST) };
93 unsafe { gl.disable(glow::SCISSOR_TEST) };
94 unsafe { gl.disable(glow::BLEND) };
95 unsafe { gl.disable(glow::CULL_FACE) };
96 unsafe { gl.disable(glow::POLYGON_OFFSET_FILL) };
97 unsafe { gl.disable(glow::SAMPLE_ALPHA_TO_COVERAGE) };
98 if self.features.contains(wgt::Features::DEPTH_CLIP_CONTROL) {
99 unsafe { gl.disable(glow::DEPTH_CLAMP) };
100 }
101
102 unsafe { gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, None) };
103 let mut current_index_buffer = self.current_index_buffer.lock();
104 *current_index_buffer = None;
105 }
106
107 unsafe fn set_attachment(
108 &self,
109 gl: &glow::Context,
110 fbo_target: u32,
111 attachment: u32,
112 view: &super::TextureView,
113 depth_slice: Option<u32>,
114 sample_count: u32,
115 ) {
116 match view.inner {
117 super::TextureInner::Renderbuffer { raw } => {
118 unsafe {
119 gl.framebuffer_renderbuffer(
120 fbo_target,
121 attachment,
122 glow::RENDERBUFFER,
123 Some(raw),
124 )
125 };
126 }
127 super::TextureInner::DefaultRenderbuffer => panic!("Unexpected default RBO"),
128 super::TextureInner::Texture { raw, target } => {
129 let num_layers = view.array_layers.end - view.array_layers.start;
130 if num_layers > 1 {
131 #[cfg(webgl)]
132 unsafe {
133 gl.framebuffer_texture_multiview_ovr(
134 fbo_target,
135 attachment,
136 Some(raw),
137 view.mip_levels.start as i32,
138 view.array_layers.start as i32,
139 num_layers as i32,
140 )
141 };
142 } else if is_layered_target(target) {
143 let layer = if target == glow::TEXTURE_3D {
144 depth_slice.unwrap() as i32
145 } else {
146 view.array_layers.start as i32
147 };
148 unsafe {
149 gl.framebuffer_texture_layer(
150 fbo_target,
151 attachment,
152 Some(raw),
153 view.mip_levels.start as i32,
154 layer,
155 )
156 };
157 } else {
158 unsafe {
159 assert_eq!(view.mip_levels.len(), 1);
160 if sample_count != 1 {
161 gl.framebuffer_texture_2d_multisample(
162 fbo_target,
163 attachment,
164 get_2d_target(target, view.array_layers.start),
165 Some(raw),
166 view.mip_levels.start as i32,
167 sample_count as i32,
168 )
169 } else {
170 gl.framebuffer_texture_2d(
171 fbo_target,
172 attachment,
173 get_2d_target(target, view.array_layers.start),
174 Some(raw),
175 view.mip_levels.start as i32,
176 )
177 }
178 };
179 }
180 }
181 #[cfg(webgl)]
182 super::TextureInner::ExternalFramebuffer { ref inner } => unsafe {
183 gl.bind_external_framebuffer(glow::FRAMEBUFFER, inner);
184 },
185 #[cfg(native)]
186 super::TextureInner::ExternalNativeFramebuffer { ref inner } => unsafe {
187 gl.bind_framebuffer(glow::FRAMEBUFFER, Some(*inner));
188 },
189 }
190 }
191
192 unsafe fn process(
194 &self,
195 gl: &glow::Context,
196 command: &C,
197 #[cfg_attr(target_arch = "wasm32", allow(unused))] data_bytes: &[u8],
198 queries: &[glow::Query],
199 program: Option<&super::LinkedProgram>,
200 ) {
201 let first_instance_location =
202 program.and_then(|program| program.first_instance_location.as_ref());
203 match *command {
204 C::Draw {
205 topology,
206 first_vertex,
207 vertex_count,
208 instance_count,
209 first_instance,
210 } => {
211 let supports_full_instancing = self
212 .shared
213 .private_caps
214 .contains(PrivateCapabilities::FULLY_FEATURED_INSTANCING);
215
216 if supports_full_instancing {
217 unsafe {
218 gl.draw_arrays_instanced_base_instance(
219 topology,
220 first_vertex as i32,
221 vertex_count as i32,
222 instance_count as i32,
223 first_instance,
224 )
225 }
226 } else {
227 unsafe {
233 gl.draw_arrays_instanced(
234 topology,
235 first_vertex as i32,
236 vertex_count as i32,
237 instance_count as i32,
238 )
239 }
240 };
241 }
242 C::DrawIndexed {
243 topology,
244 index_type,
245 index_count,
246 index_offset,
247 base_vertex,
248 first_instance,
249 instance_count,
250 } => {
251 let supports_full_instancing = self
252 .shared
253 .private_caps
254 .contains(PrivateCapabilities::FULLY_FEATURED_INSTANCING);
255
256 if supports_full_instancing {
257 unsafe {
258 gl.draw_elements_instanced_base_vertex_base_instance(
259 topology,
260 index_count as i32,
261 index_type,
262 index_offset as i32,
263 instance_count as i32,
264 base_vertex,
265 first_instance,
266 )
267 }
268 } else {
269 if base_vertex == 0 {
272 unsafe {
273 gl.draw_elements_instanced(
277 topology,
278 index_count as i32,
279 index_type,
280 index_offset as i32,
281 instance_count as i32,
282 )
283 }
284 } else {
285 unsafe {
287 gl.draw_elements_instanced_base_vertex(
288 topology,
289 index_count as _,
290 index_type,
291 index_offset as i32,
292 instance_count as i32,
293 base_vertex,
294 )
295 }
296 }
297 }
298 }
299 C::DrawIndirect {
300 topology,
301 indirect_buf,
302 indirect_offset,
303 } => {
304 unsafe { gl.uniform_1_u32(first_instance_location, 0) };
305
306 unsafe { gl.bind_buffer(glow::DRAW_INDIRECT_BUFFER, Some(indirect_buf)) };
307 unsafe { gl.draw_arrays_indirect_offset(topology, indirect_offset as i32) };
308 }
309 C::DrawIndexedIndirect {
310 topology,
311 index_type,
312 indirect_buf,
313 indirect_offset,
314 } => {
315 unsafe { gl.uniform_1_u32(first_instance_location, 0) };
316
317 unsafe { gl.bind_buffer(glow::DRAW_INDIRECT_BUFFER, Some(indirect_buf)) };
318 unsafe {
319 gl.draw_elements_indirect_offset(topology, index_type, indirect_offset as i32)
320 };
321 }
322 C::Dispatch(group_counts) => {
323 unsafe { gl.dispatch_compute(group_counts[0], group_counts[1], group_counts[2]) };
324 }
325 C::DispatchIndirect {
326 indirect_buf,
327 indirect_offset,
328 } => {
329 unsafe { gl.bind_buffer(glow::DISPATCH_INDIRECT_BUFFER, Some(indirect_buf)) };
330 unsafe { gl.dispatch_compute_indirect(indirect_offset as i32) };
331 }
332 C::ClearBuffer(ref op) => {
333 let super::ClearBufferOp {
334 ref dst,
335 dst_target,
336 ref range,
337 } = **op;
338 match dst.raw {
339 Some(buffer) => {
340 let can_use_zero_buffer = self
349 .shared
350 .private_caps
351 .contains(PrivateCapabilities::INDEX_BUFFER_ROLE_CHANGE)
352 || dst_target != glow::ELEMENT_ARRAY_BUFFER;
353
354 if can_use_zero_buffer {
355 unsafe {
356 gl.bind_buffer(glow::COPY_READ_BUFFER, Some(self.zero_buffer))
357 };
358 unsafe { gl.bind_buffer(dst_target, Some(buffer)) };
359 let mut dst_offset = range.start;
360 while dst_offset < range.end {
361 let size =
362 (range.end - dst_offset).min(super::ZERO_BUFFER_SIZE as u64);
363 unsafe {
364 gl.copy_buffer_sub_data(
365 glow::COPY_READ_BUFFER,
366 dst_target,
367 0,
368 dst_offset as i32,
369 size as i32,
370 )
371 };
372 dst_offset += size;
373 }
374 } else {
375 unsafe { gl.bind_buffer(dst_target, Some(buffer)) };
376 let zeroes = vec![0u8; (range.end - range.start) as usize];
377 unsafe {
378 gl.buffer_sub_data_u8_slice(dst_target, range.start as i32, &zeroes)
379 };
380 }
381 }
382 None => {
383 let mut map_state = lock(&dst.map_state);
384 map_state.data.as_mut().unwrap().as_mut_slice()
385 [range.start as usize..range.end as usize]
386 .fill(0);
387 }
388 }
389 }
390 C::CopyBufferToBuffer(ref op) => {
391 let super::BufferToBufferCopy {
392 ref src,
393 src_target,
394 ref dst,
395 dst_target,
396 copy,
397 } = **op;
398 let copy_src_target = glow::COPY_READ_BUFFER;
399 let is_index_buffer_only_element_dst = !self
400 .shared
401 .private_caps
402 .contains(PrivateCapabilities::INDEX_BUFFER_ROLE_CHANGE)
403 && dst_target == glow::ELEMENT_ARRAY_BUFFER
404 || src_target == glow::ELEMENT_ARRAY_BUFFER;
405
406 let copy_dst_target = if is_index_buffer_only_element_dst {
408 glow::ELEMENT_ARRAY_BUFFER
409 } else {
410 glow::COPY_WRITE_BUFFER
411 };
412 let size = copy.size.get() as usize;
413 match (src.raw, dst.raw) {
414 (Some(ref src), Some(ref dst)) => {
415 unsafe { gl.bind_buffer(copy_src_target, Some(*src)) };
416 unsafe { gl.bind_buffer(copy_dst_target, Some(*dst)) };
417 unsafe {
418 gl.copy_buffer_sub_data(
419 copy_src_target,
420 copy_dst_target,
421 copy.src_offset as _,
422 copy.dst_offset as _,
423 copy.size.get() as _,
424 )
425 };
426 }
427 (Some(src), None) => {
428 let mut map_state = lock(&dst.map_state);
429 let dst_data = &mut map_state.data.as_mut().unwrap().as_mut_slice()
430 [copy.dst_offset as usize..copy.dst_offset as usize + size];
431
432 unsafe { gl.bind_buffer(copy_src_target, Some(src)) };
433 unsafe {
434 self.shared.get_buffer_sub_data(
435 gl,
436 copy_src_target,
437 copy.src_offset as i32,
438 dst_data,
439 )
440 };
441 }
442 (None, Some(dst)) => {
443 let map_state = lock(&src.map_state);
444 let src_data = &map_state.data.as_ref().unwrap().as_slice()
445 [copy.src_offset as usize..copy.src_offset as usize + size];
446 unsafe { gl.bind_buffer(copy_dst_target, Some(dst)) };
447 unsafe {
448 gl.buffer_sub_data_u8_slice(
449 copy_dst_target,
450 copy.dst_offset as i32,
451 src_data,
452 )
453 };
454 }
455 (None, None) => {
456 todo!()
457 }
458 }
459 unsafe { gl.bind_buffer(copy_src_target, None) };
460 if is_index_buffer_only_element_dst {
461 unsafe {
462 gl.bind_buffer(
463 glow::ELEMENT_ARRAY_BUFFER,
464 *self.current_index_buffer.lock(),
465 )
466 };
467 } else {
468 unsafe { gl.bind_buffer(copy_dst_target, None) };
469 }
470 }
471 #[cfg(webgl)]
472 C::CopyExternalImageToTexture(ref op) => {
473 let super::ExternalImageToTextureCopy {
474 ref src,
475 dst,
476 dst_target,
477 dst_format,
478 dst_premultiplication,
479 ref copy,
480 } = **op;
481 const UNPACK_FLIP_Y_WEBGL: u32 =
482 web_sys::WebGl2RenderingContext::UNPACK_FLIP_Y_WEBGL;
483 const UNPACK_PREMULTIPLY_ALPHA_WEBGL: u32 =
484 web_sys::WebGl2RenderingContext::UNPACK_PREMULTIPLY_ALPHA_WEBGL;
485
486 unsafe {
487 if src.flip_y {
488 gl.pixel_store_bool(UNPACK_FLIP_Y_WEBGL, true);
489 }
490 if dst_premultiplication {
491 gl.pixel_store_bool(UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
492 }
493 }
494
495 unsafe { gl.bind_texture(dst_target, Some(dst)) };
496 let format_desc = self.shared.describe_texture_format(dst_format);
497 if is_layered_target(dst_target) {
498 let z_offset = get_z_offset(dst_target, ©.dst_base);
499
500 match src.source {
501 wgt::ExternalImageSource::ImageBitmap(ref b) => unsafe {
502 gl.tex_sub_image_3d_with_image_bitmap(
503 dst_target,
504 copy.dst_base.mip_level as i32,
505 copy.dst_base.origin.x as i32,
506 copy.dst_base.origin.y as i32,
507 z_offset as i32,
508 copy.size.width as i32,
509 copy.size.height as i32,
510 copy.size.depth as i32,
511 format_desc.external,
512 format_desc.data_type,
513 b,
514 );
515 },
516 wgt::ExternalImageSource::HTMLImageElement(ref i) => unsafe {
517 gl.tex_sub_image_3d_with_html_image_element(
518 dst_target,
519 copy.dst_base.mip_level as i32,
520 copy.dst_base.origin.x as i32,
521 copy.dst_base.origin.y as i32,
522 z_offset as i32,
523 copy.size.width as i32,
524 copy.size.height as i32,
525 copy.size.depth as i32,
526 format_desc.external,
527 format_desc.data_type,
528 i,
529 );
530 },
531 wgt::ExternalImageSource::HTMLVideoElement(ref v) => unsafe {
532 gl.tex_sub_image_3d_with_html_video_element(
533 dst_target,
534 copy.dst_base.mip_level as i32,
535 copy.dst_base.origin.x as i32,
536 copy.dst_base.origin.y as i32,
537 z_offset as i32,
538 copy.size.width as i32,
539 copy.size.height as i32,
540 copy.size.depth as i32,
541 format_desc.external,
542 format_desc.data_type,
543 v,
544 );
545 },
546 #[cfg(not(web_sys_unstable_apis))]
547 wgt::ExternalImageSource::VideoFrame(_) => {
548 unimplemented!("web_sys_unstable_apis is needed for glow")
549 }
550 #[cfg(web_sys_unstable_apis)]
551 wgt::ExternalImageSource::VideoFrame(ref v) => unsafe {
552 gl.tex_sub_image_3d_with_video_frame(
553 dst_target,
554 copy.dst_base.mip_level as i32,
555 copy.dst_base.origin.x as i32,
556 copy.dst_base.origin.y as i32,
557 z_offset as i32,
558 copy.size.width as i32,
559 copy.size.height as i32,
560 copy.size.depth as i32,
561 format_desc.external,
562 format_desc.data_type,
563 v,
564 )
565 },
566 wgt::ExternalImageSource::ImageData(ref i) => unsafe {
567 gl.tex_sub_image_3d_with_image_data(
568 dst_target,
569 copy.dst_base.mip_level as i32,
570 copy.dst_base.origin.x as i32,
571 copy.dst_base.origin.y as i32,
572 z_offset as i32,
573 copy.size.width as i32,
574 copy.size.height as i32,
575 copy.size.depth as i32,
576 format_desc.external,
577 format_desc.data_type,
578 i,
579 );
580 },
581 wgt::ExternalImageSource::HTMLCanvasElement(ref c) => unsafe {
582 gl.tex_sub_image_3d_with_html_canvas_element(
583 dst_target,
584 copy.dst_base.mip_level as i32,
585 copy.dst_base.origin.x as i32,
586 copy.dst_base.origin.y as i32,
587 z_offset as i32,
588 copy.size.width as i32,
589 copy.size.height as i32,
590 copy.size.depth as i32,
591 format_desc.external,
592 format_desc.data_type,
593 c,
594 );
595 },
596 wgt::ExternalImageSource::OffscreenCanvas(_) => unreachable!(),
597 }
598 } else {
599 let dst_target = get_2d_target(dst_target, copy.dst_base.array_layer);
600
601 match src.source {
602 wgt::ExternalImageSource::ImageBitmap(ref b) => unsafe {
603 gl.tex_sub_image_2d_with_image_bitmap_and_width_and_height(
604 dst_target,
605 copy.dst_base.mip_level as i32,
606 copy.dst_base.origin.x as i32,
607 copy.dst_base.origin.y as i32,
608 copy.size.width as i32,
609 copy.size.height as i32,
610 format_desc.external,
611 format_desc.data_type,
612 b,
613 );
614 },
615 wgt::ExternalImageSource::HTMLImageElement(ref i) => unsafe {
616 gl.tex_sub_image_2d_with_html_image_and_width_and_height(
617 dst_target,
618 copy.dst_base.mip_level as i32,
619 copy.dst_base.origin.x as i32,
620 copy.dst_base.origin.y as i32,
621 copy.size.width as i32,
622 copy.size.height as i32,
623 format_desc.external,
624 format_desc.data_type,
625 i,
626 )
627 },
628 wgt::ExternalImageSource::HTMLVideoElement(ref v) => unsafe {
629 gl.tex_sub_image_2d_with_html_video_and_width_and_height(
630 dst_target,
631 copy.dst_base.mip_level as i32,
632 copy.dst_base.origin.x as i32,
633 copy.dst_base.origin.y as i32,
634 copy.size.width as i32,
635 copy.size.height as i32,
636 format_desc.external,
637 format_desc.data_type,
638 v,
639 )
640 },
641 #[cfg(not(web_sys_unstable_apis))]
642 wgt::ExternalImageSource::VideoFrame(_) => {
643 unimplemented!("web_sys_unstable_apis is needed for glow")
644 }
645 #[cfg(web_sys_unstable_apis)]
646 wgt::ExternalImageSource::VideoFrame(ref v) => unsafe {
647 gl.tex_sub_image_2d_with_video_frame_and_width_and_height(
648 dst_target,
649 copy.dst_base.mip_level as i32,
650 copy.dst_base.origin.x as i32,
651 copy.dst_base.origin.y as i32,
652 copy.size.width as i32,
653 copy.size.height as i32,
654 format_desc.external,
655 format_desc.data_type,
656 v,
657 )
658 },
659 wgt::ExternalImageSource::ImageData(ref i) => unsafe {
660 gl.tex_sub_image_2d_with_image_data_and_width_and_height(
661 dst_target,
662 copy.dst_base.mip_level as i32,
663 copy.dst_base.origin.x as i32,
664 copy.dst_base.origin.y as i32,
665 copy.size.width as i32,
666 copy.size.height as i32,
667 format_desc.external,
668 format_desc.data_type,
669 i,
670 );
671 },
672 wgt::ExternalImageSource::HTMLCanvasElement(ref c) => unsafe {
673 gl.tex_sub_image_2d_with_html_canvas_and_width_and_height(
674 dst_target,
675 copy.dst_base.mip_level as i32,
676 copy.dst_base.origin.x as i32,
677 copy.dst_base.origin.y as i32,
678 copy.size.width as i32,
679 copy.size.height as i32,
680 format_desc.external,
681 format_desc.data_type,
682 c,
683 )
684 },
685 wgt::ExternalImageSource::OffscreenCanvas(_) => unreachable!(),
686 }
687 }
688
689 unsafe {
690 if src.flip_y {
691 gl.pixel_store_bool(UNPACK_FLIP_Y_WEBGL, false);
692 }
693 if dst_premultiplication {
694 gl.pixel_store_bool(UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
695 }
696 }
697 }
698 C::CopyTextureToTexture(ref op) => {
699 let super::TextureToTextureCopy {
700 src,
701 src_target,
702 dst,
703 dst_target,
704 ref copy,
705 } = **op;
706 unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(self.copy_fbo)) };
708 if is_layered_target(src_target) {
709 unsafe {
711 gl.framebuffer_texture_layer(
712 glow::READ_FRAMEBUFFER,
713 glow::COLOR_ATTACHMENT0,
714 Some(src),
715 copy.src_base.mip_level as i32,
716 copy.src_base.array_layer as i32,
717 )
718 };
719 } else {
720 unsafe {
721 gl.framebuffer_texture_2d(
722 glow::READ_FRAMEBUFFER,
723 glow::COLOR_ATTACHMENT0,
724 src_target,
725 Some(src),
726 copy.src_base.mip_level as i32,
727 )
728 };
729 }
730
731 unsafe { gl.bind_texture(dst_target, Some(dst)) };
732 if is_layered_target(dst_target) {
733 unsafe {
734 gl.copy_tex_sub_image_3d(
735 dst_target,
736 copy.dst_base.mip_level as i32,
737 copy.dst_base.origin.x as i32,
738 copy.dst_base.origin.y as i32,
739 get_z_offset(dst_target, ©.dst_base) as i32,
740 copy.src_base.origin.x as i32,
741 copy.src_base.origin.y as i32,
742 copy.size.width as i32,
743 copy.size.height as i32,
744 )
745 };
746 } else {
747 unsafe {
748 gl.copy_tex_sub_image_2d(
749 get_2d_target(dst_target, copy.dst_base.array_layer),
750 copy.dst_base.mip_level as i32,
751 copy.dst_base.origin.x as i32,
752 copy.dst_base.origin.y as i32,
753 copy.src_base.origin.x as i32,
754 copy.src_base.origin.y as i32,
755 copy.size.width as i32,
756 copy.size.height as i32,
757 )
758 };
759 }
760 }
761 C::CopyBufferToTexture(ref op) => {
762 let super::BufferToTextureCopy {
763 ref src,
764 src_target: _,
765 dst,
766 dst_target,
767 dst_format,
768 ref copy,
769 } = **op;
770 let (block_width, block_height) = dst_format.block_dimensions();
771 let block_size = dst_format.block_copy_size(None).unwrap();
772 let format_desc = self.shared.describe_texture_format(dst_format);
773 let row_texels = copy
774 .buffer_layout
775 .bytes_per_row
776 .map_or(0, |bpr| block_width * bpr / block_size);
777 let column_texels = copy
778 .buffer_layout
779 .rows_per_image
780 .map_or(0, |rpi| block_height * rpi);
781
782 unsafe { gl.bind_texture(dst_target, Some(dst)) };
783 unsafe { gl.pixel_store_i32(glow::UNPACK_ROW_LENGTH, row_texels as i32) };
784 unsafe { gl.pixel_store_i32(glow::UNPACK_IMAGE_HEIGHT, column_texels as i32) };
785 let mut unbind_unpack_buffer = false;
786 if !dst_format.is_compressed() {
787 let map_state;
788 let unpack_data = match src.raw {
789 Some(buffer) => {
790 unsafe { gl.bind_buffer(glow::PIXEL_UNPACK_BUFFER, Some(buffer)) };
791 unbind_unpack_buffer = true;
792 glow::PixelUnpackData::BufferOffset(copy.buffer_layout.offset as u32)
793 }
794 None => {
795 map_state = lock(&src.map_state);
796 let src_data = &map_state.data.as_ref().unwrap().as_slice()
797 [copy.buffer_layout.offset as usize..];
798 glow::PixelUnpackData::Slice(Some(src_data))
799 }
800 };
801 if is_layered_target(dst_target) {
802 unsafe {
803 gl.tex_sub_image_3d(
804 dst_target,
805 copy.texture_base.mip_level as i32,
806 copy.texture_base.origin.x as i32,
807 copy.texture_base.origin.y as i32,
808 get_z_offset(dst_target, ©.texture_base) as i32,
809 copy.size.width as i32,
810 copy.size.height as i32,
811 copy.size.depth as i32,
812 format_desc.external,
813 format_desc.data_type,
814 unpack_data,
815 )
816 };
817 } else {
818 unsafe {
819 gl.tex_sub_image_2d(
820 get_2d_target(dst_target, copy.texture_base.array_layer),
821 copy.texture_base.mip_level as i32,
822 copy.texture_base.origin.x as i32,
823 copy.texture_base.origin.y as i32,
824 copy.size.width as i32,
825 copy.size.height as i32,
826 format_desc.external,
827 format_desc.data_type,
828 unpack_data,
829 )
830 };
831 }
832 } else {
833 let bytes_per_row = copy
834 .buffer_layout
835 .bytes_per_row
836 .unwrap_or(copy.size.width * block_size);
837 let minimum_rows_per_image = copy.size.height.div_ceil(block_height);
838 let rows_per_image = copy
839 .buffer_layout
840 .rows_per_image
841 .unwrap_or(minimum_rows_per_image);
842
843 let bytes_per_image = bytes_per_row * rows_per_image;
844 let minimum_bytes_per_image = bytes_per_row * minimum_rows_per_image;
845 let bytes_in_upload =
846 (bytes_per_image * (copy.size.depth - 1)) + minimum_bytes_per_image;
847 let offset = copy.buffer_layout.offset as u32;
848
849 let map_state;
850 let unpack_data = match src.raw {
851 Some(buffer) => {
852 unsafe { gl.bind_buffer(glow::PIXEL_UNPACK_BUFFER, Some(buffer)) };
853 unbind_unpack_buffer = true;
854 glow::CompressedPixelUnpackData::BufferRange(
855 offset..offset + bytes_in_upload,
856 )
857 }
858 None => {
859 map_state = lock(&src.map_state);
860 let src_data = &map_state.data.as_ref().unwrap().as_slice()
861 [(offset as usize)..(offset + bytes_in_upload) as usize];
862 glow::CompressedPixelUnpackData::Slice(src_data)
863 }
864 };
865
866 if is_layered_target(dst_target) {
867 unsafe {
868 gl.compressed_tex_sub_image_3d(
869 dst_target,
870 copy.texture_base.mip_level as i32,
871 copy.texture_base.origin.x as i32,
872 copy.texture_base.origin.y as i32,
873 get_z_offset(dst_target, ©.texture_base) as i32,
874 copy.size.width as i32,
875 copy.size.height as i32,
876 copy.size.depth as i32,
877 format_desc.internal,
878 unpack_data,
879 )
880 };
881 } else {
882 unsafe {
883 gl.compressed_tex_sub_image_2d(
884 get_2d_target(dst_target, copy.texture_base.array_layer),
885 copy.texture_base.mip_level as i32,
886 copy.texture_base.origin.x as i32,
887 copy.texture_base.origin.y as i32,
888 copy.size.width as i32,
889 copy.size.height as i32,
890 format_desc.internal,
891 unpack_data,
892 )
893 };
894 }
895 }
896 if unbind_unpack_buffer {
897 unsafe { gl.bind_buffer(glow::PIXEL_UNPACK_BUFFER, None) };
898 }
899 }
900 C::CopyTextureToBuffer(ref op) => {
901 let super::TextureToBufferCopy {
902 src,
903 src_target,
904 src_format,
905 ref dst,
906 dst_target: _,
907 ref copy,
908 } = **op;
909 let block_size = src_format.block_copy_size(None).unwrap();
910 if src_format.is_compressed() {
911 log::error!("Not implemented yet: compressed texture copy to buffer");
912 return;
913 }
914 if src_target == glow::TEXTURE_CUBE_MAP
915 || src_target == glow::TEXTURE_CUBE_MAP_ARRAY
916 {
917 log::error!("Not implemented yet: cubemap texture copy to buffer");
918 return;
919 }
920 let format_desc = self.shared.describe_texture_format(src_format);
921 let row_texels = copy
922 .buffer_layout
923 .bytes_per_row
924 .map_or(copy.size.width, |bpr| bpr / block_size);
925 let column_texels = copy
926 .buffer_layout
927 .rows_per_image
928 .unwrap_or(copy.size.height);
929
930 unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(self.copy_fbo)) };
931
932 let read_pixels = |offset| {
933 let mut map_state;
934 let unpack_data = match dst.raw {
935 Some(buffer) => {
936 unsafe { gl.pixel_store_i32(glow::PACK_ROW_LENGTH, row_texels as i32) };
937 unsafe { gl.bind_buffer(glow::PIXEL_PACK_BUFFER, Some(buffer)) };
938 glow::PixelPackData::BufferOffset(offset as u32)
939 }
940 None => {
941 map_state = lock(&dst.map_state);
942 let dst_data = &mut map_state.data.as_mut().unwrap().as_mut_slice()
943 [offset as usize..];
944 glow::PixelPackData::Slice(Some(dst_data))
945 }
946 };
947 unsafe {
948 gl.read_pixels(
949 copy.texture_base.origin.x as i32,
950 copy.texture_base.origin.y as i32,
951 copy.size.width as i32,
952 copy.size.height as i32,
953 format_desc.external,
954 format_desc.data_type,
955 unpack_data,
956 )
957 };
958 };
959
960 match src_target {
961 glow::TEXTURE_2D => {
962 unsafe {
963 gl.framebuffer_texture_2d(
964 glow::READ_FRAMEBUFFER,
965 glow::COLOR_ATTACHMENT0,
966 src_target,
967 Some(src),
968 copy.texture_base.mip_level as i32,
969 )
970 };
971 read_pixels(copy.buffer_layout.offset);
972 }
973 glow::TEXTURE_2D_ARRAY => {
974 unsafe {
975 gl.framebuffer_texture_layer(
976 glow::READ_FRAMEBUFFER,
977 glow::COLOR_ATTACHMENT0,
978 Some(src),
979 copy.texture_base.mip_level as i32,
980 copy.texture_base.array_layer as i32,
981 )
982 };
983 read_pixels(copy.buffer_layout.offset);
984 }
985 glow::TEXTURE_3D => {
986 for z in copy.texture_base.origin.z..copy.size.depth {
987 unsafe {
988 gl.framebuffer_texture_layer(
989 glow::READ_FRAMEBUFFER,
990 glow::COLOR_ATTACHMENT0,
991 Some(src),
992 copy.texture_base.mip_level as i32,
993 z as i32,
994 )
995 };
996 let offset = copy.buffer_layout.offset
997 + (z * block_size * row_texels * column_texels) as u64;
998 read_pixels(offset);
999 }
1000 }
1001 glow::TEXTURE_CUBE_MAP | glow::TEXTURE_CUBE_MAP_ARRAY => unimplemented!(),
1002 _ => unreachable!(),
1003 }
1004 }
1005 C::SetIndexBuffer(buffer) => {
1006 unsafe { gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(buffer)) };
1007 let mut current_index_buffer = self.current_index_buffer.lock();
1008 *current_index_buffer = Some(buffer);
1009 }
1010 C::BeginQuery(query, target) => {
1011 unsafe { gl.begin_query(target, query) };
1012 }
1013 C::EndQuery(target) => {
1014 unsafe { gl.end_query(target) };
1015 }
1016 C::TimestampQuery(query) => {
1017 unsafe { gl.query_counter(query, glow::TIMESTAMP) };
1018 }
1019 C::CopyQueryResults(ref op) => {
1020 let super::QueryResultsCopy {
1021 ref query_range,
1022 ref dst,
1023 dst_target,
1024 dst_offset,
1025 } = **op;
1026 if self
1027 .shared
1028 .private_caps
1029 .contains(PrivateCapabilities::QUERY_BUFFERS)
1030 && dst.raw.is_some()
1031 {
1032 unsafe {
1033 let query_size = 8;
1036
1037 let query_range_size = query_size * query_range.len();
1038
1039 let buffer = gl.create_buffer().ok();
1040 gl.bind_buffer(glow::QUERY_BUFFER, buffer);
1041 gl.buffer_data_size(
1042 glow::QUERY_BUFFER,
1043 query_range_size as _,
1044 glow::STREAM_COPY,
1045 );
1046
1047 for (i, &query) in queries
1048 [query_range.start as usize..query_range.end as usize]
1049 .iter()
1050 .enumerate()
1051 {
1052 gl.get_query_parameter_u64_with_offset(
1053 query,
1054 glow::QUERY_RESULT,
1055 query_size * i,
1056 )
1057 }
1058 gl.bind_buffer(dst_target, dst.raw);
1059 gl.copy_buffer_sub_data(
1060 glow::QUERY_BUFFER,
1061 dst_target,
1062 0,
1063 dst_offset as _,
1064 query_range_size as _,
1065 );
1066 if let Some(buffer) = buffer {
1067 gl.delete_buffer(buffer)
1068 }
1069 }
1070 } else {
1071 let mut temp_query_results = self.temp_query_results.lock();
1072 temp_query_results.clear();
1073 for &query in
1074 queries[query_range.start as usize..query_range.end as usize].iter()
1075 {
1076 let mut result: u64 = 0;
1077 unsafe {
1078 if self
1079 .shared
1080 .private_caps
1081 .contains(PrivateCapabilities::QUERY_64BIT)
1082 {
1083 let result: *mut u64 = &mut result;
1084 gl.get_query_parameter_u64_with_offset(
1085 query,
1086 glow::QUERY_RESULT,
1087 result as usize,
1088 )
1089 } else {
1090 result =
1091 gl.get_query_parameter_u32(query, glow::QUERY_RESULT) as u64;
1092 }
1093 };
1094 temp_query_results.push(result);
1095 }
1096 let query_data = bytemuck::cast_slice(&temp_query_results);
1097 match dst.raw {
1098 Some(buffer) => {
1099 unsafe { gl.bind_buffer(dst_target, Some(buffer)) };
1100 unsafe {
1101 gl.buffer_sub_data_u8_slice(
1102 dst_target,
1103 dst_offset as i32,
1104 query_data,
1105 )
1106 };
1107 }
1108 None => {
1109 let mut map_state = lock(&dst.map_state);
1110 let data = map_state.data.as_mut().unwrap();
1111 let len = query_data.len().min(data.len());
1112 data[..len].copy_from_slice(&query_data[..len]);
1113 }
1114 }
1115 }
1116 }
1117 C::ResetFramebuffer { is_default } => {
1118 if is_default {
1119 unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None) };
1120 } else {
1121 unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, Some(self.draw_fbo)) };
1122 unsafe {
1123 gl.framebuffer_texture_2d(
1124 glow::DRAW_FRAMEBUFFER,
1125 glow::DEPTH_STENCIL_ATTACHMENT,
1126 glow::TEXTURE_2D,
1127 None,
1128 0,
1129 )
1130 };
1131 for i in 0..self.shared.limits.max_color_attachments {
1132 let target = glow::COLOR_ATTACHMENT0 + i;
1133 unsafe {
1134 gl.framebuffer_texture_2d(
1135 glow::DRAW_FRAMEBUFFER,
1136 target,
1137 glow::TEXTURE_2D,
1138 None,
1139 0,
1140 )
1141 };
1142 }
1143 }
1144 unsafe { gl.color_mask(true, true, true, true) };
1145 unsafe { gl.depth_mask(true) };
1146 unsafe { gl.stencil_mask(!0) };
1147 unsafe { gl.disable(glow::DEPTH_TEST) };
1148 unsafe { gl.disable(glow::STENCIL_TEST) };
1149 unsafe { gl.disable(glow::SCISSOR_TEST) };
1150 }
1151 C::BindAttachment(ref op) => {
1152 let super::AttachmentBinding {
1153 attachment,
1154 ref view,
1155 depth_slice,
1156 sample_count,
1157 } = **op;
1158 unsafe {
1159 self.set_attachment(
1160 gl,
1161 glow::DRAW_FRAMEBUFFER,
1162 attachment,
1163 view,
1164 depth_slice,
1165 sample_count,
1166 )
1167 };
1168 }
1169 C::ResolveAttachment(ref op) => {
1170 let super::AttachmentResolve {
1171 attachment,
1172 ref dst,
1173 ref size,
1174 } = **op;
1175 unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(self.draw_fbo)) };
1176 unsafe { gl.read_buffer(attachment) };
1177 unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, Some(self.copy_fbo)) };
1178 unsafe {
1179 self.set_attachment(
1180 gl,
1181 glow::DRAW_FRAMEBUFFER,
1182 glow::COLOR_ATTACHMENT0,
1183 dst,
1184 None,
1185 1,
1186 )
1187 };
1188 unsafe {
1189 gl.blit_framebuffer(
1190 0,
1191 0,
1192 size.width as i32,
1193 size.height as i32,
1194 0,
1195 0,
1196 size.width as i32,
1197 size.height as i32,
1198 glow::COLOR_BUFFER_BIT,
1199 glow::NEAREST,
1200 )
1201 };
1202 unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, None) };
1203 unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, Some(self.draw_fbo)) };
1204 }
1205 C::InvalidateAttachments(ref list) => {
1206 if self
1207 .shared
1208 .private_caps
1209 .contains(PrivateCapabilities::INVALIDATE_FRAMEBUFFER)
1210 {
1211 unsafe { gl.invalidate_framebuffer(glow::DRAW_FRAMEBUFFER, list) };
1212 }
1213 }
1214 C::SetDrawColorBuffers(count) => {
1215 self.draw_buffer_count.store(count, Ordering::Relaxed);
1216 let indices = (0..count as u32)
1217 .map(|i| glow::COLOR_ATTACHMENT0 + i)
1218 .collect::<ArrayVec<_, { crate::MAX_COLOR_ATTACHMENTS }>>();
1219 unsafe { gl.draw_buffers(&indices) };
1220 }
1221 C::ClearColorF {
1222 draw_buffer,
1223 ref color,
1224 is_srgb,
1225 } => {
1226 if self
1227 .shared
1228 .workarounds
1229 .contains(super::Workarounds::MESA_I915_SRGB_SHADER_CLEAR)
1230 && is_srgb
1231 {
1232 unsafe { self.perform_shader_clear(gl, draw_buffer, *color) };
1233 } else {
1234 unsafe { gl.clear_buffer_f32_slice(glow::COLOR, draw_buffer, color) };
1235 }
1236 }
1237 C::ClearColorU(draw_buffer, ref color) => {
1238 unsafe { gl.clear_buffer_u32_slice(glow::COLOR, draw_buffer, color) };
1239 }
1240 C::ClearColorI(draw_buffer, ref color) => {
1241 unsafe { gl.clear_buffer_i32_slice(glow::COLOR, draw_buffer, color) };
1242 }
1243 C::ClearDepth(depth) => {
1244 unsafe {
1247 gl.clear_depth_f32(depth);
1248 gl.clear(glow::DEPTH_BUFFER_BIT);
1249 }
1250 }
1251 C::ClearStencil(value) => {
1252 unsafe {
1255 gl.clear_stencil(value as i32);
1256 gl.clear(glow::STENCIL_BUFFER_BIT);
1257 }
1258 }
1259 C::ClearDepthAndStencil(depth, stencil_value) => {
1260 unsafe {
1263 gl.clear_depth_f32(depth);
1264 gl.clear_stencil(stencil_value as i32);
1265 gl.clear(glow::DEPTH_BUFFER_BIT | glow::STENCIL_BUFFER_BIT);
1266 }
1267 }
1268 C::BufferBarrier(raw, usage) => {
1269 let mut flags = 0;
1270 if usage.contains(wgt::BufferUses::VERTEX) {
1271 flags |= glow::VERTEX_ATTRIB_ARRAY_BARRIER_BIT;
1272 unsafe { gl.bind_buffer(glow::ARRAY_BUFFER, Some(raw)) };
1273 unsafe { gl.vertex_attrib_pointer_f32(0, 1, glow::BYTE, true, 0, 0) };
1274 }
1275 if usage.contains(wgt::BufferUses::INDEX) {
1276 flags |= glow::ELEMENT_ARRAY_BARRIER_BIT;
1277 unsafe { gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(raw)) };
1278 }
1279 if usage.contains(wgt::BufferUses::UNIFORM) {
1280 flags |= glow::UNIFORM_BARRIER_BIT;
1281 }
1282 if usage.contains(wgt::BufferUses::INDIRECT) {
1283 flags |= glow::COMMAND_BARRIER_BIT;
1284 unsafe { gl.bind_buffer(glow::DRAW_INDIRECT_BUFFER, Some(raw)) };
1285 }
1286 if usage.contains(wgt::BufferUses::COPY_SRC) {
1287 flags |= glow::PIXEL_BUFFER_BARRIER_BIT;
1288 unsafe { gl.bind_buffer(glow::PIXEL_UNPACK_BUFFER, Some(raw)) };
1289 }
1290 if usage.contains(wgt::BufferUses::COPY_DST) {
1291 flags |= glow::PIXEL_BUFFER_BARRIER_BIT;
1292 unsafe { gl.bind_buffer(glow::PIXEL_PACK_BUFFER, Some(raw)) };
1293 }
1294 if usage.intersects(wgt::BufferUses::MAP_READ | wgt::BufferUses::MAP_WRITE) {
1295 flags |= glow::BUFFER_UPDATE_BARRIER_BIT;
1296 }
1297 if usage.intersects(
1298 wgt::BufferUses::STORAGE_READ_ONLY | wgt::BufferUses::STORAGE_READ_WRITE,
1299 ) {
1300 flags |= glow::SHADER_STORAGE_BARRIER_BIT;
1301 }
1302 unsafe { gl.memory_barrier(flags) };
1303 }
1304 C::TextureBarrier(usage) => {
1309 let mut flags = 0;
1310 if usage.contains(wgt::TextureUses::RESOURCE) {
1311 flags |= glow::TEXTURE_FETCH_BARRIER_BIT;
1312 }
1313 if usage.intersects(
1314 wgt::TextureUses::STORAGE_READ_ONLY
1315 | wgt::TextureUses::STORAGE_WRITE_ONLY
1316 | wgt::TextureUses::STORAGE_READ_WRITE,
1317 ) {
1318 flags |= glow::SHADER_IMAGE_ACCESS_BARRIER_BIT;
1319 }
1320 if usage.intersects(wgt::TextureUses::COPY_SRC) {
1321 flags |= glow::PIXEL_BUFFER_BARRIER_BIT;
1322 }
1323 if usage.contains(wgt::TextureUses::COPY_DST) {
1324 flags |= glow::TEXTURE_UPDATE_BARRIER_BIT;
1325 }
1326 if usage.intersects(
1327 wgt::TextureUses::COLOR_TARGET
1328 | wgt::TextureUses::DEPTH_STENCIL_READ
1329 | wgt::TextureUses::DEPTH_STENCIL_WRITE,
1330 ) {
1331 flags |= glow::FRAMEBUFFER_BARRIER_BIT;
1332 }
1333 unsafe { gl.memory_barrier(flags) };
1334 }
1335 C::SetViewport {
1336 ref rect,
1337 ref depth,
1338 } => {
1339 unsafe { gl.viewport(rect.x, rect.y, rect.w, rect.h) };
1340 unsafe { gl.depth_range_f32(depth.start, depth.end) };
1341 }
1342 C::SetScissor(_)
1345 | C::SetStencilFunc { .. }
1346 | C::SetStencilOps { .. }
1347 | C::SetVertexAttribute {
1348 buffer: Some(_), ..
1349 }
1350 | C::UnsetVertexAttribute(_)
1351 | C::SetDepth(_)
1352 | C::ConfigureDepthStencil(_)
1353 | C::SetProgram(_)
1354 | C::BindSampler(..)
1355 | C::BindTexture { .. }
1356 | C::SetColorTarget {
1357 draw_buffer_index: None,
1358 ..
1359 } => {}
1360 C::SetVertexAttribute {
1361 buffer: None,
1362 buffer_desc: _,
1363 attribute_desc: ref vat,
1364 } => {
1365 unsafe { gl.bind_buffer(glow::ARRAY_BUFFER, None) };
1366 unsafe { gl.enable_vertex_attrib_array(vat.location) };
1367 match vat.format_desc.attrib_kind {
1368 super::VertexAttribKind::Float => unsafe {
1369 gl.vertex_attrib_format_f32(
1370 vat.location,
1371 vat.format_desc.element_count,
1372 vat.format_desc.element_format,
1373 true, vat.offset,
1375 )
1376 },
1377 super::VertexAttribKind::Integer => unsafe {
1378 gl.vertex_attrib_format_i32(
1379 vat.location,
1380 vat.format_desc.element_count,
1381 vat.format_desc.element_format,
1382 vat.offset,
1383 )
1384 },
1385 }
1386
1387 unsafe { gl.vertex_attrib_binding(vat.location, vat.buffer_index) };
1390 }
1391 C::SetVertexBuffer {
1392 index,
1393 ref buffer,
1394 ref buffer_desc,
1395 } => {
1396 unsafe { gl.vertex_binding_divisor(index, buffer_desc.step as u32) };
1397 unsafe {
1398 gl.bind_vertex_buffer(
1399 index,
1400 Some(buffer.raw),
1401 buffer.offset as i32,
1402 buffer_desc.stride as i32,
1403 )
1404 };
1405 }
1406 C::SetDepthBias(bias) => {
1407 if bias.is_enabled() {
1408 unsafe { gl.enable(glow::POLYGON_OFFSET_FILL) };
1409 unsafe { gl.polygon_offset(bias.slope_scale, bias.constant as f32) };
1410 } else {
1411 unsafe { gl.disable(glow::POLYGON_OFFSET_FILL) };
1412 }
1413 }
1414 C::SetAlphaToCoverage(enabled) => {
1415 if enabled {
1416 unsafe { gl.enable(glow::SAMPLE_ALPHA_TO_COVERAGE) };
1417 } else {
1418 unsafe { gl.disable(glow::SAMPLE_ALPHA_TO_COVERAGE) };
1419 }
1420 }
1421 C::SetPrimitive(ref state) => {
1422 unsafe { gl.front_face(state.front_face) };
1423 if state.cull_face != 0 {
1424 unsafe { gl.enable(glow::CULL_FACE) };
1425 unsafe { gl.cull_face(state.cull_face) };
1426 } else {
1427 unsafe { gl.disable(glow::CULL_FACE) };
1428 }
1429 if self.features.contains(wgt::Features::DEPTH_CLIP_CONTROL) {
1430 if state.unclipped_depth {
1432 unsafe { gl.enable(glow::DEPTH_CLAMP) };
1433 } else {
1434 unsafe { gl.disable(glow::DEPTH_CLAMP) };
1435 }
1436 }
1437 if self.features.contains(wgt::Features::POLYGON_MODE_LINE) {
1439 unsafe { gl.polygon_mode(glow::FRONT_AND_BACK, state.polygon_mode) };
1440 }
1441 }
1442 C::SetBlendConstant(c) => {
1443 unsafe { gl.blend_color(c[0], c[1], c[2], c[3]) };
1444 }
1445 C::SetColorTarget {
1446 draw_buffer_index: Some(index),
1447 desc: super::ColorTargetDesc { mask, ref blend },
1448 } => {
1449 use wgt::ColorWrites as Cw;
1450 unsafe {
1451 gl.color_mask_draw_buffer(
1452 index,
1453 mask.contains(Cw::RED),
1454 mask.contains(Cw::GREEN),
1455 mask.contains(Cw::BLUE),
1456 mask.contains(Cw::ALPHA),
1457 )
1458 };
1459 if let Some(ref blend) = *blend {
1460 unsafe { gl.enable_draw_buffer(glow::BLEND, index) };
1461 if blend.color != blend.alpha {
1462 unsafe {
1463 gl.blend_equation_separate_draw_buffer(
1464 index,
1465 blend.color.equation,
1466 blend.alpha.equation,
1467 )
1468 };
1469 unsafe {
1470 gl.blend_func_separate_draw_buffer(
1471 index,
1472 blend.color.src,
1473 blend.color.dst,
1474 blend.alpha.src,
1475 blend.alpha.dst,
1476 )
1477 };
1478 } else {
1479 unsafe { gl.blend_equation_draw_buffer(index, blend.color.equation) };
1480 unsafe {
1481 gl.blend_func_draw_buffer(index, blend.color.src, blend.color.dst)
1482 };
1483 }
1484 } else {
1485 unsafe { gl.disable_draw_buffer(glow::BLEND, index) };
1486 }
1487 }
1488 C::BindBuffer {
1489 target,
1490 slot,
1491 buffer,
1492 offset,
1493 size,
1494 } => {
1495 unsafe { gl.bind_buffer_range(target, slot, Some(buffer), offset, size) };
1496 }
1497 C::BindImage { slot, ref binding } => {
1498 unsafe {
1499 gl.bind_image_texture(
1500 slot,
1501 Some(binding.raw),
1502 binding.mip_level as i32,
1503 binding.array_layer.is_none(),
1504 binding.array_layer.unwrap_or_default() as i32,
1505 binding.access,
1506 binding.format,
1507 )
1508 };
1509 }
1510 C::InsertDebugMarker(ref range) => {
1511 let marker = extract_marker(data_bytes, range);
1512 unsafe {
1513 if self
1514 .shared
1515 .private_caps
1516 .contains(PrivateCapabilities::DEBUG_FNS)
1517 {
1518 gl.debug_message_insert(
1519 glow::DEBUG_SOURCE_APPLICATION,
1520 glow::DEBUG_TYPE_MARKER,
1521 DEBUG_ID,
1522 glow::DEBUG_SEVERITY_NOTIFICATION,
1523 to_debug_str(marker),
1524 )
1525 }
1526 };
1527 }
1528 C::PushDebugGroup(ref range) => {
1529 let marker = extract_marker(data_bytes, range);
1530 unsafe {
1531 if self
1532 .shared
1533 .private_caps
1534 .contains(PrivateCapabilities::DEBUG_FNS)
1535 {
1536 gl.push_debug_group(
1537 glow::DEBUG_SOURCE_APPLICATION,
1538 DEBUG_ID,
1539 to_debug_str(marker),
1540 )
1541 }
1542 };
1543 }
1544 C::PopDebugGroup => {
1545 unsafe {
1546 if self
1547 .shared
1548 .private_caps
1549 .contains(PrivateCapabilities::DEBUG_FNS)
1550 {
1551 gl.pop_debug_group()
1552 }
1553 };
1554 }
1555 C::SetImmediates { ref data } => {
1556 for uniform in program.into_iter().flat_map(|program| &program.immediates_descs) {
1560 unsafe { set_immediate(gl, uniform, data_bytes, data.start + uniform.offset) };
1561 }
1562 }
1563 C::SetClipDistances {
1564 old_count,
1565 new_count,
1566 } => {
1567 for i in new_count..old_count {
1569 unsafe { gl.disable(glow::CLIP_DISTANCE0 + i) };
1570 }
1571
1572 for i in old_count..new_count {
1574 unsafe { gl.enable(glow::CLIP_DISTANCE0 + i) };
1575 }
1576 }
1577 }
1578 }
1579}
1580
1581impl crate::Queue for super::Queue {
1582 type A = super::Api;
1583
1584 unsafe fn submit(
1585 &self,
1586 command_buffers: &[&super::CommandBuffer],
1587 _surface_textures: &[&super::Texture],
1588 (signal_fence, signal_value): (&super::Fence, crate::FenceValue),
1589 ) -> Result<(), crate::DeviceError> {
1590 let shared = Arc::clone(&self.shared);
1591 let gl = &shared.context.lock();
1592 let unread = shared.unread_links.load(Ordering::Relaxed);
1598 if unread > 0 {
1599 for command in command_buffers.iter().flat_map(|cmd_buf| cmd_buf.commands.iter()) {
1600 if let C::SetProgram(ref inner) = *command {
1601 drop(unsafe { inner.read_link(gl, &shared.unread_links) });
1602 }
1603 }
1604 if shared.unread_links.load(Ordering::Relaxed) < unread {
1612 for program in shared.program_cache.lock().values().flatten() {
1613 drop(unsafe { program.read_link(gl, &shared.unread_links) });
1614 }
1615 }
1616 }
1617 let emulates_first_instance = !shared
1620 .private_caps
1621 .contains(PrivateCapabilities::FULLY_FEATURED_INSTANCING);
1622 let mut state = self.gl_state.lock();
1623 for cmd_buf in command_buffers.iter() {
1624 unsafe { self.reset_state(gl) };
1629 if let Some(ref label) = cmd_buf.label {
1630 if self
1631 .shared
1632 .private_caps
1633 .contains(PrivateCapabilities::DEBUG_FNS)
1634 {
1635 unsafe {
1636 gl.push_debug_group(
1637 glow::DEBUG_SOURCE_APPLICATION,
1638 DEBUG_ID,
1639 to_debug_str(label),
1640 )
1641 };
1642 }
1643 }
1644
1645 state.reset();
1646 let mut program = None;
1649 for command in cmd_buf.commands.iter() {
1650 if let C::SetProgram(ref inner) = *command {
1651 program = Some(unsafe { inner.linked(gl, &shared.unread_links) });
1652 }
1653 let first_instance = program
1654 .as_deref()
1655 .and_then(|program| program.first_instance_location.as_ref())
1656 .filter(|_| emulates_first_instance);
1657 if !unsafe { state.apply(gl, command, first_instance) } {
1658 unsafe {
1659 self.process(
1660 gl,
1661 command,
1662 &cmd_buf.data_bytes,
1663 &cmd_buf.queries,
1664 program.as_deref(),
1665 )
1666 };
1667 }
1668 }
1669 unsafe { state.finish(gl) };
1670
1671 if cmd_buf.label.is_some()
1672 && self
1673 .shared
1674 .private_caps
1675 .contains(PrivateCapabilities::DEBUG_FNS)
1676 {
1677 unsafe { gl.pop_debug_group() };
1678 }
1679 }
1680
1681 signal_fence.maintain(gl);
1682 signal_fence.signal(gl, signal_value)?;
1683
1684 unsafe { gl.flush() };
1688
1689 Ok(())
1690 }
1691
1692 unsafe fn present(
1693 &self,
1694 surface: &super::Surface,
1695 texture: super::Texture,
1696 ) -> Result<(), crate::SurfaceError> {
1697 unsafe { surface.present(texture, &self.shared.context) }
1698 }
1699
1700 unsafe fn get_timestamp_period(&self) -> f32 {
1701 1.0
1702 }
1703
1704 unsafe fn wait_for_idle(&self) -> Result<(), crate::DeviceError> {
1705 let gl = &self.shared.context.lock();
1706 unsafe { gl.finish() };
1707 Ok(())
1708 }
1709}
1710
1711#[cfg(send_sync)]
1712unsafe impl Sync for super::Queue {}
1713#[cfg(send_sync)]
1714unsafe impl Send for super::Queue {}
1715
1716unsafe fn set_immediate(
1718 gl: &glow::Context,
1719 uniform: &super::ImmediateDesc,
1720 data_bytes: &[u8],
1721 offset: u32,
1722) {
1723 fn get_data<T, const COUNT: usize>(data: &[u8], offset: u32) -> [T; COUNT]
1724 where
1725 [T; COUNT]: bytemuck::AnyBitPattern,
1726 {
1727 let data_required = size_of::<T>() * COUNT;
1728 let raw = &data[(offset as usize)..][..data_required];
1729 bytemuck::pod_read_unaligned(raw)
1730 }
1731
1732 let location = Some(&uniform.location);
1733 use nt::glsl::{GlslScalar, GlslUniformType, GlslVectorSize};
1734 match uniform.ty {
1735 GlslUniformType::Scalar(GlslScalar::F32) => {
1739 let data = get_data::<f32, 1>(data_bytes, offset)[0];
1740 unsafe { gl.uniform_1_f32(location, data) };
1741 }
1742 GlslUniformType::Vector {
1743 size: GlslVectorSize::Bi,
1744 scalar: GlslScalar::F32,
1745 } => {
1746 let data = &get_data::<f32, 2>(data_bytes, offset);
1747 unsafe { gl.uniform_2_f32_slice(location, data) };
1748 }
1749 GlslUniformType::Vector {
1750 size: GlslVectorSize::Tri,
1751 scalar: GlslScalar::F32,
1752 } => {
1753 let data = &get_data::<f32, 3>(data_bytes, offset);
1754 unsafe { gl.uniform_3_f32_slice(location, data) };
1755 }
1756 GlslUniformType::Vector {
1757 size: GlslVectorSize::Quad,
1758 scalar: GlslScalar::F32,
1759 } => {
1760 let data = &get_data::<f32, 4>(data_bytes, offset);
1761 unsafe { gl.uniform_4_f32_slice(location, data) };
1762 }
1763
1764 GlslUniformType::Scalar(GlslScalar::I32) => {
1768 let data = get_data::<i32, 1>(data_bytes, offset)[0];
1769 unsafe { gl.uniform_1_i32(location, data) };
1770 }
1771 GlslUniformType::Vector {
1772 size: GlslVectorSize::Bi,
1773 scalar: GlslScalar::I32,
1774 } => {
1775 let data = &get_data::<i32, 2>(data_bytes, offset);
1776 unsafe { gl.uniform_2_i32_slice(location, data) };
1777 }
1778 GlslUniformType::Vector {
1779 size: GlslVectorSize::Tri,
1780 scalar: GlslScalar::I32,
1781 } => {
1782 let data = &get_data::<i32, 3>(data_bytes, offset);
1783 unsafe { gl.uniform_3_i32_slice(location, data) };
1784 }
1785 GlslUniformType::Vector {
1786 size: GlslVectorSize::Quad,
1787 scalar: GlslScalar::I32,
1788 } => {
1789 let data = &get_data::<i32, 4>(data_bytes, offset);
1790 unsafe { gl.uniform_4_i32_slice(location, data) };
1791 }
1792
1793 GlslUniformType::Scalar(GlslScalar::U32) => {
1797 let data = get_data::<u32, 1>(data_bytes, offset)[0];
1798 unsafe { gl.uniform_1_u32(location, data) };
1799 }
1800 GlslUniformType::Vector {
1801 size: GlslVectorSize::Bi,
1802 scalar: GlslScalar::U32,
1803 } => {
1804 let data = &get_data::<u32, 2>(data_bytes, offset);
1805 unsafe { gl.uniform_2_u32_slice(location, data) };
1806 }
1807 GlslUniformType::Vector {
1808 size: GlslVectorSize::Tri,
1809 scalar: GlslScalar::U32,
1810 } => {
1811 let data = &get_data::<u32, 3>(data_bytes, offset);
1812 unsafe { gl.uniform_3_u32_slice(location, data) };
1813 }
1814 GlslUniformType::Vector {
1815 size: GlslVectorSize::Quad,
1816 scalar: GlslScalar::U32,
1817 } => {
1818 let data = &get_data::<u32, 4>(data_bytes, offset);
1819 unsafe { gl.uniform_4_u32_slice(location, data) };
1820 }
1821
1822 GlslUniformType::Matrix {
1826 columns: GlslVectorSize::Bi,
1827 rows: GlslVectorSize::Bi,
1828 scalar: GlslScalar::F32,
1829 } => {
1830 let data = &get_data::<f32, 4>(data_bytes, offset);
1831 unsafe { gl.uniform_matrix_2_f32_slice(location, false, data) };
1832 }
1833 GlslUniformType::Matrix {
1834 columns: GlslVectorSize::Bi,
1835 rows: GlslVectorSize::Tri,
1836 scalar: GlslScalar::F32,
1837 } => {
1838 let unpacked_data = &get_data::<f32, 8>(data_bytes, offset);
1840 #[rustfmt::skip]
1841 let packed_data = [
1842 unpacked_data[0], unpacked_data[1], unpacked_data[2],
1843 unpacked_data[4], unpacked_data[5], unpacked_data[6],
1844 ];
1845 unsafe { gl.uniform_matrix_2x3_f32_slice(location, false, &packed_data) };
1846 }
1847 GlslUniformType::Matrix {
1848 columns: GlslVectorSize::Bi,
1849 rows: GlslVectorSize::Quad,
1850 scalar: GlslScalar::F32,
1851 } => {
1852 let data = &get_data::<f32, 8>(data_bytes, offset);
1853 unsafe { gl.uniform_matrix_2x4_f32_slice(location, false, data) };
1854 }
1855
1856 GlslUniformType::Matrix {
1860 columns: GlslVectorSize::Tri,
1861 rows: GlslVectorSize::Bi,
1862 scalar: GlslScalar::F32,
1863 } => {
1864 let data = &get_data::<f32, 6>(data_bytes, offset);
1865 unsafe { gl.uniform_matrix_3x2_f32_slice(location, false, data) };
1866 }
1867 GlslUniformType::Matrix {
1868 columns: GlslVectorSize::Tri,
1869 rows: GlslVectorSize::Tri,
1870 scalar: GlslScalar::F32,
1871 } => {
1872 let unpacked_data = &get_data::<f32, 12>(data_bytes, offset);
1874 #[rustfmt::skip]
1875 let packed_data = [
1876 unpacked_data[0], unpacked_data[1], unpacked_data[2],
1877 unpacked_data[4], unpacked_data[5], unpacked_data[6],
1878 unpacked_data[8], unpacked_data[9], unpacked_data[10],
1879 ];
1880 unsafe { gl.uniform_matrix_3_f32_slice(location, false, &packed_data) };
1881 }
1882 GlslUniformType::Matrix {
1883 columns: GlslVectorSize::Tri,
1884 rows: GlslVectorSize::Quad,
1885 scalar: GlslScalar::F32,
1886 } => {
1887 let data = &get_data::<f32, 12>(data_bytes, offset);
1888 unsafe { gl.uniform_matrix_3x4_f32_slice(location, false, data) };
1889 }
1890
1891 GlslUniformType::Matrix {
1895 columns: GlslVectorSize::Quad,
1896 rows: GlslVectorSize::Bi,
1897 scalar: GlslScalar::F32,
1898 } => {
1899 let data = &get_data::<f32, 8>(data_bytes, offset);
1900 unsafe { gl.uniform_matrix_4x2_f32_slice(location, false, data) };
1901 }
1902 GlslUniformType::Matrix {
1903 columns: GlslVectorSize::Quad,
1904 rows: GlslVectorSize::Tri,
1905 scalar: GlslScalar::F32,
1906 } => {
1907 let unpacked_data = &get_data::<f32, 16>(data_bytes, offset);
1909 #[rustfmt::skip]
1910 let packed_data = [
1911 unpacked_data[0], unpacked_data[1], unpacked_data[2],
1912 unpacked_data[4], unpacked_data[5], unpacked_data[6],
1913 unpacked_data[8], unpacked_data[9], unpacked_data[10],
1914 unpacked_data[12], unpacked_data[13], unpacked_data[14],
1915 ];
1916 unsafe { gl.uniform_matrix_4x3_f32_slice(location, false, &packed_data) };
1917 }
1918 GlslUniformType::Matrix {
1919 columns: GlslVectorSize::Quad,
1920 rows: GlslVectorSize::Quad,
1921 scalar: GlslScalar::F32,
1922 } => {
1923 let data = &get_data::<f32, 16>(data_bytes, offset);
1924 unsafe { gl.uniform_matrix_4_f32_slice(location, false, data) };
1925 }
1926 _ => panic!("Unsupported uniform datatype: {:?}!", uniform.ty),
1927 }
1928}