Mismatching behavior on Vulkan/GL with 2D texture array create_view function

[kaphula]

Attempting to create a texture view for 2D texture array (a texture with depth_or_array_layers > 1 produces this error message on GL backend:

ERROR [wgpu_hal::gles] wgpu-hal heuristics assumed that the view dimension will be equal to `D2Array` rather than `D2`.
`D2` textures with `depth_or_array_layers == 1` are assumed to have view dimension `D2`
`D2` textures with `depth_or_array_layers > 1` are assumed to have view dimension `D2Array`
`D2` textures with `depth_or_array_layers == 6` are assumed to have view dimension `Cube`
`D2` textures with `depth_or_array_layers > 6 && depth_or_array_layers % 6 == 0` are assumed to have view dimension `CubeArray`

I am using the code below to generate mipmaps for 2D texture array. On Vulkan it works and renders properly without errors. On GL I get the above error message and the mipmaps render wrong textures. (quick search for "HERE IS THE PROBLEMATIC VIEW ON GL BACKEND:")

 pub fn generate_mipmaps(
      device: &wgpu::Device,
      queue: &Queue,
      texture: &wgpu::Texture,
      format: TextureFormat,
      mip_count: u32,
      texture_type: MipMapGenerationType,
   ) {
      assert!(mip_count >= 1, "mip count cannot be 0!");
      if mip_count == 1 {
         return;
      }

      let mut init_encoder =
         device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });

      let shader = device.create_shader_module(wgpu::include_wgsl!("blit_mipmap.wgsl"));

      let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
         label: Some("blit_mipmaps"),
         layout: None,
         vertex: wgpu::VertexState {
            module: &shader,
            entry_point: Some("vs_main"),
            compilation_options: Default::default(),
            buffers: &[],
         },
         fragment: Some(wgpu::FragmentState {
            module: &shader,
            entry_point: Some("fs_main"),
            compilation_options: Default::default(),
            targets: &[Some(format.into())],
         }),
         primitive: wgpu::PrimitiveState {
            topology: wgpu::PrimitiveTopology::TriangleList,
            ..Default::default()
         },
         depth_stencil: None,
         multisample: wgpu::MultisampleState::default(),
         multiview: None,
         cache: None,
      });

      let bind_group_layout = pipeline.get_bind_group_layout(0);

      let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
         label: Some("mip"),
         address_mode_u: wgpu::AddressMode::ClampToEdge,
         address_mode_v: wgpu::AddressMode::ClampToEdge,
         address_mode_w: wgpu::AddressMode::ClampToEdge,
         mag_filter: wgpu::FilterMode::Linear,
         min_filter: wgpu::FilterMode::Linear,
         mipmap_filter: wgpu::FilterMode::Nearest,
         ..Default::default()
      });

      match texture_type {
         MipMapGenerationType::Texture2D => {
            let views = (0..mip_count)
               .map(|mip| {
                  texture.create_view(&wgpu::TextureViewDescriptor {
                     label: Some("mip"),
                     format: None,
                     dimension: None,
                     aspect: wgpu::TextureAspect::All,
                     base_mip_level: mip,
                     mip_level_count: Some(1),
                     base_array_layer: 0,
                     array_layer_count: None,
                  })
               })
               .collect::<Vec<_>>();

            for target_mip in 1..mip_count as usize {
               let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
                  layout: &bind_group_layout,
                  entries: &[
                     wgpu::BindGroupEntry {
                        binding: 0,
                        resource: wgpu::BindingResource::TextureView(&views[target_mip - 1]),
                     },
                     wgpu::BindGroupEntry {
                        binding: 1,
                        resource: wgpu::BindingResource::Sampler(&sampler),
                     },
                  ],
                  label: None,
               });

               let mut rpass = init_encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                  label: None,
                  color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                     view: &views[target_mip],
                     resolve_target: None,
                     ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
                        store: wgpu::StoreOp::Store,
                     },
                  })],
                  depth_stencil_attachment: None,
                  timestamp_writes: None,
                  occlusion_query_set: None,
               });
               rpass.set_pipeline(&pipeline);
               rpass.set_bind_group(0, &bind_group, &[]);
               rpass.draw(0..3, 0..1);
            }

         }
         MipMapGenerationType::Texture2DArray { num_pages } => {
            for page_num in 0..num_pages {
               let views = (0..mip_count)
                  .map(|mip| {
                    // HERE IS THE PROBLEMATIC VIEW ON GL BACKEND:
                     texture.create_view(&wgpu::TextureViewDescriptor {
                        label: Some("mip"),
                        format: None,
                        dimension: Some(wgpu::TextureViewDimension::D2), 
                        aspect: wgpu::TextureAspect::All,
                        base_mip_level: mip,
                        mip_level_count: Some(1),
                        base_array_layer: page_num as u32,
                        array_layer_count: None,
                     })
                  })
                  .collect::<Vec<_>>();

               for target_mip in 1..mip_count as usize {
                  let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
                     layout: &bind_group_layout,
                     entries: &[
                        wgpu::BindGroupEntry {
                           binding: 0,
                           resource: wgpu::BindingResource::TextureView(&views[target_mip - 1]),
                        },
                        wgpu::BindGroupEntry {
                           binding: 1,
                           resource: wgpu::BindingResource::Sampler(&sampler),
                        },
                     ],
                     label: None,
                  });

                  let mut rpass = init_encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                     label: None,
                     color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                        view: &views[target_mip],
                        resolve_target: None,
                        ops: wgpu::Operations {
                           load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
                           store: wgpu::StoreOp::Store,
                        },
                     })],
                     depth_stencil_attachment: None,
                     timestamp_writes: None,
                     occlusion_query_set: None,
                  });
                  rpass.set_pipeline(&pipeline);
                  rpass.set_bind_group(0, &bind_group, &[]);

                  let num_draw_calls = 3;

                  rpass.draw(0..num_draw_calls, 0..1);
               }
            }
         }
      }
      queue.submit(Some(init_encoder.finish()));
   }

pub enum MipMapGenerationType {
   Texture2D,
   Texture2DArray {
      num_pages: usize
   },
}

WGPU version:

wgpu = { version = "23.0.0", default-features = false, features = [
    "fragile-send-sync-non-atomic-wasm",
    "wgsl",
] }

Instance flags:

      let instance_flags = wgpu::InstanceFlags::default() | wgpu::InstanceFlags::ALLOW_UNDERLYING_NONCOMPLIANT_ADAPTER;
      let id = InstanceDescriptor {
         backends: Backends::GL,
         flags: instance_flags,
         dx12_shader_compiler: Default::default(),
         gles_minor_version: Default::default(),
      };

Features:

      let (device, queue) = pollster::block_on(adapter.request_device(
         &wgpu::DeviceDescriptor {
            label: None,
            required_features: Features::default() | Features::TEXTURE_COMPRESSION_BC,
            required_limits: Default::default(),
            memory_hints: Default::default(),
         },
         None, 
      ))
         .map_err(|e| e.to_string())?;

Platform: Linux
GPU: AMD Radeon RX 6600 (RADV NAVI23)

[tasogare3710]

@kaphula It is unclear if this is the correct texture view alias tuple since the target of the original texture is unknown (D2Array to D2?).
It is also unnatural that TextureViewDescriptor::array_layer_count is None even though one of the targets is an array texture.
If the target argument of the glTextureView function is GL_TEXTURE_2D, the numlayers argument must be 1, but in wgpu, if array_layer_count is None, it represents the number of remaining layers.

https://docs.rs/wgpu/latest/wgpu/type.TextureViewDescriptor.html#structfield.array_layer_count

---

BTW, doesn't gles backend not support view texture aliases?

[tasogare3710]

It looks like glow doesn't support textureview so I think it's a wgpu emulation issue after.

wgpu/wgpu-hal/src/gles/mod.rs

Lines 453 to 454 in 09178f2

	/// More information can be found in issues #1614 and #1574
	fn log_failing_target_heuristics(view_dimension: wgt::TextureViewDimension, target: u32) {

It seems to be related to the cube map issue, as noted in the comments. #2161 as well.
My guess is that view texture aliases cannot be implemented due to limitations of the cubemap issue. It is technically possible to use separate backends for gl, gles, and webgl.

[tasogare3710]

But, if the alias target is TEXTURE2D, the layer count is 1.

[cwfitzgerald]

So WebGPU compat mode has a textureBindingViewDimension which allows the user to tell us what kind of texture to make it on OpenGL. We should implement this.

[kaphula]

@tasogare3710 I am not sure what you are asking, if anything. As I said the same code works correctly with Vulkan but not OpenGL. If there is anything more you want me to do regarding this, let me know.

I did notice on Renderdoc that cubemaps are being used for the array textures. I suppose this is some kind of optimization done by wgpu automatically behind the scenes if the number of pages is small enough?

[tasogare3710]

@kaphula

I did notice on Renderdoc that cubemaps are being used for the array textures.

Cubemaps? Is it correct that image type is array and image view is cubemap?

@cwfitzgerald To add if the wgpu validation error is implemented without problems, OpenGL will return an error due to self limitations. Even if glTextureView are available, image to view compatibility has stronger limitations than vulkan.

[tasogare3710]

Fundamental issue is that webgpu's textures and texture views are incompatible with opengl's textures and texture views because they are mappings of vulkan's images and image views.

There may be nothing else that can be done with the gles backend other than to fallback to compatibility-mode, since the case where glTextureView can be used is not taken into account.