Workaround for alpha to coverage state leaking on (Web)GL renderer (#…

…1596)

* Workaround for alpha to coverage state leaking on (Web)GL renderer
Plus, use `Web` hardware tier when rendering with GLES.

* Rename HardwareTier::Web to Basic

* match bool -> if

---------

Co-authored-by: Emil Ernerfeldt <[email protected]>

crates/re_renderer/src/config.rs

@@ -4,23 +4,41 @@
 /// but instead support set of features, each a superset of the next.
 #[derive(Clone, Copy, Debug)]
 pub enum HardwareTier {
-    /// Maintains strict WebGL capability.
-    Web,
-    // Run natively with Vulkan/Metal but don't demand anything that isn't widely available.
+    /// For WebGL and native OpenGL. Maintains strict WebGL capability.
+    Basic,
+
+    /// Run natively with Vulkan/Metal but don't demand anything that isn't widely available.
     Native,
     // Run natively with Vulkan/Metal and require additional features.
     //HighEnd
 }
 
+impl HardwareTier {
+    /// Temporary workaround until [this GL state leaking fix](https://github.com/gfx-rs/wgpu/pull/3589) is landed.
+    /// All our target platforms should support alpha to coverage.
+    pub fn support_alpha_to_coverage(&self) -> bool {
+        match self {
+            HardwareTier::Basic => false,
+            HardwareTier::Native => true,
+        }
+    }
+
+    /// Whether the current hardware tier supports sampling from textures with a sample count higher than 1.
+    pub fn support_sampling_msaa_texture(&self) -> bool {
+        match self {
+            HardwareTier::Basic => false,
+            HardwareTier::Native => true,
+        }
+    }
+}
+
 impl Default for HardwareTier {
     fn default() -> Self {
-        #[cfg(target_arch = "wasm32")]
-        {
-            Self::Web
-        }
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            Self::Native
+        // Use "Basic" tier for actual web but also if someone forces the GL backend!
+        if supported_backends() == wgpu::Backends::GL {
+            HardwareTier::Basic
+        } else {
+            HardwareTier::Native
         }
     }
 }

crates/re_renderer/src/renderer/depth_cloud.rs

@@ -394,7 +394,10 @@ impl Renderer for DepthCloudRenderer {
             multisample: wgpu::MultisampleState {
                 // We discard pixels to do the round cutout, therefore we need to
                 // calculate our own sampling mask.
-                alpha_to_coverage_enabled: true,
+                alpha_to_coverage_enabled: shared_data
+                    .config
+                    .hardware_tier
+                    .support_alpha_to_coverage(),
                 ..ViewBuilder::MAIN_TARGET_DEFAULT_MSAA_STATE
             },
         };

crates/re_renderer/src/renderer/lines.rs

@@ -742,7 +742,10 @@ impl Renderer for LineRenderer {
                 depth_stencil: ViewBuilder::MAIN_TARGET_DEFAULT_DEPTH_STATE,
                 multisample: wgpu::MultisampleState {
                     // We discard pixels to do the round cutout, therefore we need to calculate our own sampling mask.
-                    alpha_to_coverage_enabled: true,
+                    alpha_to_coverage_enabled: shared_data
+                        .config
+                        .hardware_tier
+                        .support_alpha_to_coverage(),
                     ..ViewBuilder::MAIN_TARGET_DEFAULT_MSAA_STATE
                 },
             },

crates/re_renderer/src/renderer/outlines.rs

@@ -199,11 +199,12 @@ impl OutlineMaskProcessor {
 
     /// Number of MSAA samples used for the outline mask target.
     pub fn mask_sample_count(tier: HardwareTier) -> u32 {
-        match tier {
-            HardwareTier::Web => 1,
+        if tier.support_sampling_msaa_texture() {
             // The MSAA shader variant deals with *exactly* 4 samples.
             // See `jumpflooding_step_msaa.wgsl`.
-            HardwareTier::Native => 4,
+            4
+        } else {
+            1
         }
     }
 

crates/re_renderer/src/renderer/point_cloud.rs

@@ -556,7 +556,10 @@ impl Renderer for PointCloudRenderer {
             multisample: wgpu::MultisampleState {
                 // We discard pixels to do the round cutout, therefore we need to calculate
                 // our own sampling mask.
-                alpha_to_coverage_enabled: true,
+                alpha_to_coverage_enabled: shared_data
+                    .config
+                    .hardware_tier
+                    .support_alpha_to_coverage(),
                 ..ViewBuilder::MAIN_TARGET_DEFAULT_MSAA_STATE
             },
         };