[gles] Implement support for external textures

This enables the use of GL_OES_EGL_image_external_essl3 on gles
when the `EXTERNAL_TEXTURE` feature is requested and creates
the required bindings.

Author: cmeissl

wgpu-hal/src/gles/adapter.rs

@@ -488,6 +488,11 @@ impl super::Adapter {
             wgt::Features::SHADER_EARLY_DEPTH_TEST,
             supported((3, 1), (4, 2)) || extensions.contains("GL_ARB_shader_image_load_store"),
         );
+        features.set(
+            wgt::Features::EXTERNAL_TEXTURE,
+            es_ver.is_some_and(|v| v >= (3, 0))
+                && extensions.contains("GL_OES_EGL_image_external_essl3"),
+        );
         if extensions.contains("GL_ARB_timer_query") {
             features.set(wgt::Features::TIMESTAMP_QUERY, true);
             features.set(wgt::Features::TIMESTAMP_QUERY_INSIDE_ENCODERS, true);

wgpu-hal/src/gles/command.rs

@@ -805,6 +805,41 @@ impl crate::CommandEncoder for super::CommandEncoder {
                         binding: binding.clone(),
                     });
                 }
+                super::RawBinding::ExternalTexture {
+                    raw,
+                    target,
+                    params_raw,
+                    params_offset,
+                    params_size,
+                } => {
+                    // Bind the texture to its texture unit slot
+                    dirty_textures |= 1 << slot;
+                    self.state.texture_slots[slot as usize].tex_target = target;
+                    self.cmd_buffer.commands.push(C::BindTexture {
+                        slot,
+                        texture: raw,
+                        target,
+                        aspects: crate::FormatAspects::COLOR,
+                        mip_levels: 0..1,
+                    });
+                    // Bind the params SSBO to its shader storage buffer binding point
+                    let params_slot = layout
+                        .naga_options
+                        .external_texture_binding_map
+                        .get(&naga::ResourceBinding {
+                            group: index,
+                            binding: binding_layout.binding,
+                        })
+                        .map(|t| t.params as u32)
+                        .unwrap();
+                    self.cmd_buffer.commands.push(C::BindBuffer {
+                        target: glow::SHADER_STORAGE_BUFFER,
+                        slot: params_slot,
+                        buffer: params_raw,
+                        offset: params_offset,
+                        size: params_size,
+                    });
+                }
             }
         }
 

wgpu-hal/src/gles/device.rs

@@ -1219,6 +1219,7 @@ impl crate::Device for super::Device {
         // https://github.com/gfx-rs/wgpu/pull/3440/files#r1095726950
         writer_flags.set(glsl::WriterFlags::FORCE_POINT_SIZE, true);
         let mut binding_map = glsl::BindingMap::default();
+        let mut external_texture_binding_map = glsl::ExternalTextureBindingMap::default();
 
         for (group_index, bg_layout) in desc.bind_group_layouts.iter().enumerate() {
             let Some(bg_layout) = bg_layout else {
@@ -1252,7 +1253,28 @@ impl crate::Device for super::Device {
                         ..
                     } => &mut num_storage_buffers,
                     wgt::BindingType::AccelerationStructure { .. } => unimplemented!(),
-                    wgt::BindingType::ExternalTexture => unimplemented!(),
+                    wgt::BindingType::ExternalTexture => {
+                        let texture_slot = num_textures;
+                        let params_slot = num_storage_buffers;
+                        let count = entry.count.map_or(1, |c| c.get() as u8);
+
+                        binding_to_slot[entry.binding as usize] = texture_slot;
+                        let br = naga::ResourceBinding {
+                            group: group_index as u32,
+                            binding: entry.binding,
+                        };
+                        binding_map.insert(br, texture_slot);
+                        external_texture_binding_map.insert(
+                            br,
+                            glsl::ExternalTextureBindTarget {
+                                texture: texture_slot,
+                                params: params_slot,
+                            },
+                        );
+                        num_textures += count;
+                        num_storage_buffers += count;
+                        continue;
+                    }
                 };
 
                 binding_to_slot[entry.binding as usize] = *counter;
@@ -1278,6 +1300,7 @@ impl crate::Device for super::Device {
                 version: self.shared.shading_language_version,
                 writer_flags,
                 binding_map,
+                external_texture_binding_map,
                 zero_initialize_workgroup_memory: true,
             },
         })
@@ -1363,7 +1386,22 @@ impl crate::Device for super::Device {
                     })
                 }
                 wgt::BindingType::AccelerationStructure { .. } => unimplemented!(),
-                wgt::BindingType::ExternalTexture => unimplemented!(),
+                wgt::BindingType::ExternalTexture => {
+                    let ext_tex = &desc.external_textures[entry.resource_index as usize];
+                    let view = ext_tex.planes[0].view;
+                    let (raw, target) = view.inner.as_native();
+                    let params = &ext_tex.params;
+                    super::RawBinding::ExternalTexture {
+                        raw,
+                        target,
+                        params_raw: params.buffer.raw.unwrap(),
+                        params_offset: params.offset as i32,
+                        params_size: match params.size {
+                            Some(s) => s.get() as i32,
+                            None => (params.buffer.size - params.offset) as i32,
+                        },
+                    }
+                }
             };
             contents.push(binding);
         }

wgpu-hal/src/gles/mod.rs

@@ -595,6 +595,13 @@ enum RawBinding {
     },
     Image(ImageBinding),
     Sampler(glow::Sampler),
+    ExternalTexture {
+        raw: glow::Texture,
+        target: BindTarget,
+        params_raw: glow::Buffer,
+        params_offset: i32,
+        params_size: i32,
+    },
 }
 
 #[derive(Debug)]