@pipelab/asset-tauri 1.0.0-beta.0

package/template/src-tauri/src/lib copy.rs

@@ -0,0 +1,449 @@
+use futures_util::StreamExt;
+use std::env;
+use std::error::Error;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::{borrow::Cow, sync::Mutex, time::Instant};
+use steamworks::AppId;
+use steamworks::Client;
+use steamworks::FriendFlags;
+use steamworks::PersonaStateChange;
+use tauri::WebviewWindow;
+use tauri::{async_runtime, Emitter, Manager, RunEvent, WindowEvent};
+use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::oneshot;
+use warp::Filter;
+
+pub struct WgpuState<'win> {
+    pub queue: wgpu::Queue,
+    pub device: wgpu::Device,
+    pub surface: wgpu::Surface<'win>,
+    pub render_pipeline: wgpu::RenderPipeline,
+    pub config: Mutex<wgpu::SurfaceConfiguration>,
+}
+
+impl WgpuState<'_> {
+    pub async fn new(window: WebviewWindow) -> Self {
+        let size = window.inner_size().unwrap();
+        let instance = wgpu::Instance::default();
+        let surface = instance.create_surface(window).unwrap();
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
+                power_preference: wgpu::PowerPreference::default(),
+                force_fallback_adapter: false,
+                compatible_surface: Some(&surface),
+            })
+            .await
+            .expect("Failed to find an appropriate adapter");
+
+        let (device, queue) = adapter
+            .request_device(
+                &wgpu::DeviceDescriptor {
+                    label: None,
+                    required_features: wgpu::Features::empty(),
+                    required_limits: wgpu::Limits::downlevel_webgl2_defaults()
+                        .using_resolution(adapter.limits()),
+                },
+                None,
+            )
+            .await
+            .expect("Failed to create device");
+
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(
+                r#"
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index: u32) -> @builtin(position) vec4<f32> {
+    var position: vec4<f32>;
+    switch (vertex_index) {
+        case 0u: {
+            position = vec4<f32>(-1.0, -1.0, 0.0, 1.0); // Bottom-left
+        }
+        case 1u: {
+            position = vec4<f32>( 1.0, -1.0, 0.0, 1.0); // Bottom-right
+        }
+        case 2u: {
+            position = vec4<f32>( 0.0,  1.0, 0.0, 1.0); // Top-center
+        }
+        default: {
+            position = vec4<f32>(0.0, 0.0, 0.0, 1.0); // Default case (should not be reached)
+        }
+    }
+    return position;
+}
+
+@fragment
+fn fs_main() -> @location(0) vec4<f32> {
+    // Output a solid color
+    return vec4<f32>(0.0, 1.0, 0.0, 0.5); // Green
+}
+
+    "#,
+            )),
+        });
+
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: None,
+            push_constant_ranges: &[],
+            bind_group_layouts: &[],
+        });
+
+        let swapchain_capabilities = surface.get_capabilities(&adapter);
+        println!("swapchain_capabilities {:?}", swapchain_capabilities);
+        let swapchain_format = swapchain_capabilities.formats[0];
+
+        let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: "vs_main",
+                buffers: &[],
+                compilation_options: wgpu::PipelineCompilationOptions::default(),
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &shader,
+                entry_point: "fs_main",
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: swapchain_format,
+                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+                compilation_options: wgpu::PipelineCompilationOptions::default(),
+            }),
+            primitive: wgpu::PrimitiveState::default(),
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState::default(),
+            multiview: None,
+        });
+
+        let alpha_mode = if swapchain_capabilities
+            .alpha_modes
+            .contains(&wgpu::CompositeAlphaMode::PreMultiplied)
+        {
+            wgpu::CompositeAlphaMode::PreMultiplied
+        } else {
+            swapchain_capabilities.alpha_modes[0]
+        };
+
+        let config = wgpu::SurfaceConfiguration {
+            width: size.width,
+            height: size.height,
+            format: swapchain_format,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            present_mode: wgpu::PresentMode::Fifo,
+            alpha_mode,
+            view_formats: vec![],
+            desired_maximum_frame_latency: 2,
+        };
+
+        surface.configure(&device, &config);
+
+        Self {
+            device,
+            queue,
+            surface,
+            render_pipeline,
+            config: Mutex::new(config),
+        }
+    }
+}
+
+#[tauri::command]
+fn showOverlay() {
+    println!("Showing overlay");
+    match Client::init_app(480) {
+        Ok((client, _single)) => {
+            println!("Client created");
+            client.friends().activate_game_overlay("hey");
+            println!("Overlay shown");
+        }
+        Err(e) => eprintln!("Failed to initialize Steam client: {:?}", e),
+    }
+}
+
+async fn websocket_server(tx: Sender<String>, mut rx: Receiver<String>) {
+    let addr = SocketAddr::from(([127, 0, 0, 1], 31753));
+
+    // WebSocket upgrade
+    let ws_route = warp::path::end()
+        .and(warp::ws())
+        .map(move |ws: warp::ws::Ws| {
+            let tx = tx.clone();
+            ws.on_upgrade(move |websocket| async move {
+                let (mut ws_tx, mut ws_rx) = websocket.split();
+
+                // Forward messages to the sender
+                while let Some(result) = ws_rx.next().await {
+                    if let Ok(msg) = result {
+                        if let Ok(text) = msg.to_str() {
+                            println!("Received WebSocket message: {}", text);
+                            if tx.send(text.to_string()).await.is_err() {
+                                eprintln!("Failed to send message to channel");
+                                break;
+                            }
+                        }
+                    }
+                }
+            })
+        });
+
+    let routes = ws_route;
+
+    // Spawn HTTP server
+    tokio::spawn(warp::serve(routes).run(addr));
+    println!("WebSocket server running on ws://{}", addr);
+
+    // Process messages from the receiver
+    while let Some(message) = rx.recv().await {
+        println!("Processing message: {}", message);
+        // Handle messages as needed
+    }
+}
+
+fn setup_wgpu_overlay(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
+    println!("Webgpu rendering");
+
+    let window = app.get_webview_window("main").unwrap();
+    let size = window.inner_size()?;
+
+    // Create a WgpuState (containing the device, instance, adapter etc.)
+    // And store it in the state
+    let wgpu_state = async_runtime::block_on(WgpuState::new(window));
+    app.manage(Arc::new(wgpu_state));
+
+    let app_handle = app.app_handle().clone();
+
+    async_runtime::spawn(async move {
+        let wgpu_state = app_handle.state::<Arc<WgpuState>>();
+
+        while true {
+            let t = Instant::now();
+
+            let output = match wgpu_state.surface.get_current_texture() {
+                Ok(output) => output,
+                Err(wgpu::SurfaceError::Lost) => {
+                    println!("Surface lost, recreating surface...");
+                    continue;
+                }
+                Err(wgpu::SurfaceError::OutOfMemory) => {
+                    eprintln!("Out of memory error");
+                    continue;
+                }
+                Err(e) => {
+                    eprintln!("Failed to acquire next swap chain texture: {:?}", e);
+                    continue;
+                }
+            };
+            // let view = output
+            //     .texture
+            //     .create_view(&wgpu::TextureViewDescriptor::default());
+
+            // let mut encoder = wgpu_state
+            //     .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: &view,
+            //             resolve_target: None,
+            //             ops: wgpu::Operations {
+            //                 load: wgpu::LoadOp::Clear(wgpu::Color::GREEN),
+            //                 store: wgpu::StoreOp::Store,
+            //             },
+            //         })],
+            //         depth_stencil_attachment: None,
+            //         timestamp_writes: None,
+            //         occlusion_query_set: None,
+            //     });
+            //     rpass.set_pipeline(&wgpu_state.render_pipeline);
+            //     rpass.draw(0..3, 0..1);
+            // }
+
+            // wgpu_state.queue.submit(Some(encoder.finish()));
+
+            // Read the texture data before calling present
+            let width = output.texture.size().width as usize;
+            let height = output.texture.size().height as usize;
+            let bytes_per_pixel = 4; // RGBA8 format
+            let unaligned_bytes_per_row = width * bytes_per_pixel;
+            let aligned_bytes_per_row = ((unaligned_bytes_per_row + 255) / 256) * 256;
+            let buffer_size = aligned_bytes_per_row * output.texture.size().height as usize;
+
+            println!(
+                "Texture size: width={}, height={}",
+                output.texture.size().width,
+                output.texture.size().height
+            );
+
+            let buffer_desc = wgpu::BufferDescriptor {
+                label: Some("Staging Buffer"),
+                size: buffer_size as wgpu::BufferAddress,
+                usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            };
+            let staging_buffer = wgpu_state.device.create_buffer(&buffer_desc);
+
+            let mut encoder = wgpu_state
+                .device
+                .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+            encoder.copy_texture_to_buffer(
+                wgpu::ImageCopyTexture {
+                    texture: &output.texture,
+                    mip_level: 0,
+                    origin: wgpu::Origin3d::ZERO,
+                    aspect: wgpu::TextureAspect::All,
+                },
+                wgpu::ImageCopyBuffer {
+                    buffer: &staging_buffer,
+                    layout: wgpu::ImageDataLayout {
+                        offset: 0,
+                        bytes_per_row: Some(aligned_bytes_per_row as u32),
+                        rows_per_image: Some(output.texture.size().height),
+                    },
+                },
+                wgpu::Extent3d {
+                    width: output.texture.size().width,
+                    height: output.texture.size().height,
+                    depth_or_array_layers: 1,
+                },
+            );
+            wgpu_state.queue.submit(Some(encoder.finish()));
+
+            /** Export frame */
+            // Map the buffer to read the data
+            // println!("buffer {:?}", staging_buffer);
+
+            // Map the staging buffer to read the data
+            let buffer_slice = staging_buffer.slice(..);
+            let (sender, receiver) = futures::channel::oneshot::channel();
+            buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
+                sender.send(result).unwrap();
+            });
+            wgpu_state.device.poll(wgpu::Maintain::Wait);
+
+            receiver.await;
+
+            let unaligned_width = output.texture.size().width as usize;
+            let height = output.texture.size().height as usize;
+
+            let data = buffer_slice.get_mapped_range();
+            let image_data = data.to_vec(); // Copy buffer data to a Vec<u8>.
+            drop(data); // Release the buffer mapping.
+
+            // println!("image_data {:?}", image_data);
+
+            let mut reconstructed_data = Vec::with_capacity(unaligned_bytes_per_row * height);
+
+            for row in 0..height {
+                let start = row * aligned_bytes_per_row;
+                let end = start + unaligned_bytes_per_row; // Only take the valid portion
+                reconstructed_data.extend_from_slice(&image_data[start..end]);
+            }
+
+            assert_eq!(reconstructed_data.len(), unaligned_bytes_per_row * height);
+            println!("Reconstructed data size: {}", reconstructed_data.len());
+
+            // println!(
+            //     "image_data {:?}, expected {:?}",
+            //     image_data.len(),
+            //     aligned_bytes_per_row * height
+            // );
+            // println!(
+            //     "reconstructed_data {:?}, expected {:?}",
+            //     reconstructed_data.len(),
+            //     aligned_bytes_per_row * height
+            // );
+            // println!("Expected 1920000");
+
+            // Send the data to the webview
+            let window = app_handle.get_webview_window("main").unwrap();
+            if let Err(e) = window.emit("frame-data", reconstructed_data) {
+                eprintln!("Failed to emit data: {:?}", e);
+            }
+
+            /** End */
+            // Now call present
+            output.present();
+
+            println!("Frame rendered in: {}ms", t.elapsed().as_millis());
+        }
+    });
+
+    Ok(())
+}
+
+async fn setup_app<'a>(app: &'a mut tauri::App) -> Result<(), Box<dyn Error>> {
+    // Setup HTTP + WebSocket server
+    let (tx, rx) = tokio::sync::mpsc::channel::<String>(32);
+
+    tokio::spawn(async move {
+        websocket_server(tx, rx).await;
+    });
+
+    Ok(())
+}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    let init = match Client::init_app(480) {
+        Ok(val) => {
+            let (client, single) = val;
+            let _cb = client.register_callback(|p: PersonaStateChange| {
+                println!("Got callback: {:?}", p);
+            });
+
+            let utils = client.utils();
+            println!("Utils:");
+            println!("AppId: {:?}", utils.app_id());
+            println!("UI Language: {}", utils.ui_language());
+
+            let apps = client.apps();
+            println!("Apps");
+            println!("IsInstalled(480): {}", apps.is_app_installed(AppId(480)));
+            println!("InstallDir(480): {}", apps.app_install_dir(AppId(480)));
+            println!("BuildId: {}", apps.app_build_id());
+            println!("AppOwner: {:?}", apps.app_owner());
+            println!("Langs: {:?}", apps.available_game_languages());
+            println!("Lang: {}", apps.current_game_language());
+            println!("Beta: {:?}", apps.current_beta_name());
+
+            let friends = client.friends();
+            println!("Friends");
+            let list = friends.get_friends(FriendFlags::IMMEDIATE);
+            println!("{:?}", list);
+            for f in &list {
+                println!("Friend: {:?} - {}({:?})", f.id(), f.name(), f.state());
+                friends.request_user_information(f.id(), true);
+            }
+        }
+        Err(err) => {
+            println!("Error {}", err);
+        }
+    };
+
+    tauri::Builder::default()
+        .plugin(tauri_plugin_fs::init())
+        .setup(move |app| {
+            println!("setup");
+            let _ = setup_wgpu_overlay(app);
+            setup_app(app);
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![showOverlay])
+        .build(tauri::generate_context!())
+        .expect("error while running tauri application")
+        .run(|app_handle, event| match event {
+            RunEvent::WindowEvent {
+                label: _,
+                event: WindowEvent::Resized(size),
+                ..
+            } => {
+                //
+            }
+            RunEvent::MainEventsCleared => {}
+            _ => (),
+        });
+}