fix: fix wgpu_texture to run on android emulator on mac with disable push constants

burhankhanzada · burhankhanzada · commit 57ac9c7c4183 · 2025-11-26T17:26:32.000+01:00
diff --git a/examples/wgpu_texture/Cargo.toml b/examples/wgpu_texture/Cargo.toml
@@ -23,6 +23,10 @@ name = "wgpu_texture_lib"
 slint = { path = "../../api/rs/slint", features = ["unstable-wgpu-27", "backend-android-activity-06"] }
 bytemuck = { workspace = true }
 wgpu-27 = { workspace = true, features = ["wgsl"] }
+spin_on = "0.1.1"
 
 [build-dependencies]
 slint-build = { path = "../../api/rs/build" }
+
+[package.metadata.android]
+hardware_accelerated = true
diff --git a/examples/wgpu_texture/lib.rs b/examples/wgpu_texture/lib.rs
@@ -13,12 +13,6 @@ struct DemoRenderer {
     start_time: std::time::Instant,
 }
 
-#[repr(C)]
-#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
-struct PushConstants {
-    light_color_and_time: [f32; 4],
-}
-
 impl DemoRenderer {
     fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Self {
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
@@ -28,18 +22,9 @@ impl DemoRenderer {
             ))),
         });
 
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: None,
-            bind_group_layouts: &[],
-            push_constant_ranges: &[wgpu::PushConstantRange {
-                stages: wgpu::ShaderStages::FRAGMENT,
-                range: 0..16, // full size in bytes, aligned
-            }],
-        });
-
         let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
             label: None,
-            layout: Some(&pipeline_layout),
+            layout: None, // Auto-layout
             vertex: wgpu::VertexState {
                 module: &shader,
                 entry_point: Some("vs_main"),
@@ -50,7 +35,7 @@ impl DemoRenderer {
                 module: &shader,
                 entry_point: Some("fs_main"),
                 compilation_options: Default::default(),
-                targets: &[Some(wgpu::TextureFormat::Rgba8UnormSrgb.into())],
+                targets: &[Some(wgpu::TextureFormat::Rgba8Unorm.into())],
             }),
             primitive: wgpu::PrimitiveState::default(),
             depth_stencil: None,
@@ -77,38 +62,26 @@ impl DemoRenderer {
             mip_level_count: 1,
             sample_count: 1,
             dimension: wgpu::TextureDimension::D2,
-            format: wgpu::TextureFormat::Rgba8UnormSrgb,
+            format: wgpu::TextureFormat::Rgba8Unorm,
             usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
             view_formats: &[],
         })
     }
 
-    fn render(
-        &mut self,
-        light_red: f32,
-        light_green: f32,
-        light_blue: f32,
-        width: u32,
-        height: u32,
-    ) -> wgpu::Texture {
-        if self.texture.size().width != width || self.texture.size().height != height {
-            self.texture = Self::create_texture(&self.device, width, height);
-        }
-
-        let elapsed: f32 = self.start_time.elapsed().as_millis() as f32 / 500.;
-        let push_constants =
-            PushConstants { light_color_and_time: [light_red, light_green, light_blue, elapsed] };
+    fn render(&self, _size: slint::PhysicalSize) -> wgpu::Texture {
+        let _time = self.start_time.elapsed().as_secs_f32();
+        let texture_view = self.texture.create_view(&wgpu::TextureViewDescriptor::default());
 
         let mut encoder =
             self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
         {
             let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: None,
                 color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                    view: &self.texture.create_view(&wgpu::TextureViewDescriptor::default()),
+                    view: &texture_view,
                     resolve_target: None,
                     ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(wgpu::Color::GREEN),
+                        load: wgpu::LoadOp::Clear(wgpu::Color { r: 0.0, g: 0.0, b: 0.0, a: 1.0 }),
                         store: wgpu::StoreOp::Store,
                     },
                     depth_slice: None,
@@ -118,11 +91,6 @@ impl DemoRenderer {
                 occlusion_query_set: None,
             });
             rpass.set_pipeline(&self.pipeline);
-            rpass.set_push_constants(
-                wgpu::ShaderStages::FRAGMENT, // Stage (your constants are for fragment shader)
-                0,                            // Offset in bytes (start at 0)
-                bytemuck::bytes_of(&push_constants),
-            );
             rpass.draw(0..3, 0..1);
         }
 
@@ -132,7 +100,8 @@ impl DemoRenderer {
     }
 }
 
-pub fn main() {
+#[cfg(not(target_os = "android"))]
+fn main() {
     let mut wgpu_settings = WGPUSettings::default();
     wgpu_settings.device_required_features = wgpu::Features::PUSH_CONSTANTS;
     wgpu_settings.device_required_limits.max_push_constant_size = 16;
@@ -163,13 +132,72 @@ pub fn main() {
                 }
                 slint::RenderingState::BeforeRendering => {
                     if let (Some(renderer), Some(app)) = (renderer.as_mut(), app_weak.upgrade()) {
-                        let texture = renderer.render(
-                            app.get_selected_red(),
-                            app.get_selected_green(),
-                            app.get_selected_blue(),
+                        let texture = renderer.render(slint::PhysicalSize::new(
+                            app.get_requested_texture_width() as u32,
+                            app.get_requested_texture_height() as u32,
+                        ));
+                        app.set_texture(slint::Image::try_from(texture).unwrap());
+                        app.window().request_redraw();
+                    }
+                }
+                slint::RenderingState::AfterRendering => {}
+                slint::RenderingState::RenderingTeardown => {
+                    drop(renderer.take());
+                }
+                _ => {}
+            }
+        })
+        .expect("Unable to set rendering notifier");
+
+    app.run().unwrap();
+}
+
+#[cfg(target_os = "android")]
+fn main() {
+    let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+        flags: wgpu::InstanceFlags::empty(),
+        ..Default::default()
+    });
+
+    let adapter = spin_on::spin_on(async {
+        instance
+            .request_adapter(&Default::default())
+            .await
+            .expect("Failed to find an appropriate WGPU adapter")
+    });
+
+    let (device, queue) = spin_on::spin_on(async {
+        adapter.request_device(&Default::default()).await.expect("Failed to create WGPU device")
+    });
+
+    slint::BackendSelector::new()
+        .require_wgpu_27(WGPUConfiguration::Manual { instance, adapter, device, queue })
+        .select()
+        .expect("Unable to create Slint backend with WGPU based renderer");
+
+    let app = App::new().unwrap();
+
+    let mut renderer = None;
+
+    let app_weak = app.as_weak();
+
+    app.window()
+        .set_rendering_notifier(move |state, graphics_api| {
+            match state {
+                slint::RenderingState::RenderingSetup => {
+                    match graphics_api {
+                        slint::GraphicsAPI::WGPU27 { device, queue, .. } => {
+                            renderer = Some(DemoRenderer::new(device, queue));
+                        }
+                        _ => return,
+                    };
+                }
+                slint::RenderingState::BeforeRendering => {
+                    if let (Some(renderer), Some(app)) = (renderer.as_mut(), app_weak.upgrade()) {
+                        let texture = renderer.render(slint::PhysicalSize::new(
                             app.get_requested_texture_width() as u32,
                             app.get_requested_texture_height() as u32,
-                        );
+                        ));
                         app.set_texture(slint::Image::try_from(texture).unwrap());
                         app.window().request_redraw();
                     }
diff --git a/examples/wgpu_texture/shader.wgsl b/examples/wgpu_texture/shader.wgsl
@@ -24,12 +24,6 @@ fn vs_main(
     return output;
 }
 
-struct PushConstants {
-    light_color_and_time: vec4<f32>,
-};
-
-var<push_constant> pc: PushConstants;
-
 fn sdRoundBox(p: vec3<f32>, b: vec3<f32>, r: f32) -> f32 {
     let q = abs(p) - b;
     return length(max(q, vec3<f32>(0.0))) + min(max(q.x, max(q.y, q.z)), 0.0) - r;
@@ -59,7 +53,7 @@ fn rotateZ(r: vec3<f32>, angle: f32) -> vec3<f32> {
 
 // Distance from the scene
 fn scene(r: vec3<f32>) -> f32 {
-    let iTime = pc.light_color_and_time.w;
+    let iTime = 1.0;
     let pos = rotateZ(rotateY(r + vec3<f32>(-1.0, -1.0, 4.0), iTime), iTime);
     let cube = vec3<f32>(0.5, 0.5, 0.5);
     let edge = 0.1;
@@ -104,7 +98,7 @@ fn render(fragCoord: vec2<f32>, light_color: vec3<f32>) -> vec4<f32> {
 
 @fragment
 fn fs_main(@location(0) frag_position: vec2<f32>) -> @location(0) vec4<f32> {
-    let selected_light_color = pc.light_color_and_time.xyz;
+    let selected_light_color = vec3<f32>(0.0, 1.0, 0.0);
     let r = vec2<f32>(0.5 * frag_position.x + 1.0, 0.5 - 0.5 * frag_position.y);
     return render(r, selected_light_color);
 }
