From 28f124e8058c5af6ad245a0edfb58ab2d38c901d Mon Sep 17 00:00:00 2001 From: core Date: Sun, 5 Jan 2025 20:31:32 -0500 Subject: [PATCH] format --- starkingdoms-client/src/ecs.rs | 8 +- starkingdoms-client/src/input.rs | 12 +- starkingdoms-client/src/lib.rs | 44 +++--- starkingdoms-client/src/native/mod.rs | 4 +- starkingdoms-client/src/rendering/mipmap.rs | 72 +++++----- starkingdoms-client/src/rendering/mod.rs | 94 +++++++----- starkingdoms-client/src/rendering/renderer.rs | 135 +++++++++++------- starkingdoms-client/src/rendering/texture.rs | 9 +- starkingdoms-client/src/rendering/ui.rs | 2 +- starkingdoms-client/src/wasm/mod.rs | 9 +- 10 files changed, 224 insertions(+), 165 deletions(-) diff --git a/starkingdoms-client/src/ecs.rs b/starkingdoms-client/src/ecs.rs index 619a9302a48e72eb8af8836bfdb03cf9c30b723d..17b7e377c6b69e3bb0e3d9456c1123fcb890a334 100644 --- a/starkingdoms-client/src/ecs.rs +++ b/starkingdoms-client/src/ecs.rs @@ -5,7 +5,7 @@ use bevy_ecs::system::Resource; #[derive(Component, Debug, Clone, Copy)] pub struct Position { pub x: f32, - pub y: f32 + pub y: f32, } #[derive(Component, Debug, Clone, Copy)] pub struct Scale { @@ -22,12 +22,12 @@ pub struct SpriteTexture { pub struct SpriteBundle { pub position: Position, pub scale: Scale, - pub texture: SpriteTexture + pub texture: SpriteTexture, } #[derive(Resource, Debug)] pub struct Camera { pub x: f32, pub y: f32, - pub zoom: f32 -} \ No newline at end of file + pub zoom: f32, +} diff --git a/starkingdoms-client/src/input.rs b/starkingdoms-client/src/input.rs index f3d4c86db3d858020f46efe0cb0b5cfd65ce9c8d..788000dea9d07ee70232026bb175db62be8ab979 100644 --- a/starkingdoms-client/src/input.rs +++ b/starkingdoms-client/src/input.rs @@ -2,12 +2,6 @@ use bevy_ecs::event::Event; #[derive(Event, Debug, Copy, Clone)] pub enum MouseWheelEvent { - Line { - x: f64, - y: f64, - }, - Pixel { - x: f64, - y: f64, - } -} \ No newline at end of file + Line { x: f64, y: f64 }, + Pixel { x: f64, y: f64 }, +} diff --git a/starkingdoms-client/src/lib.rs b/starkingdoms-client/src/lib.rs index 498b1ff9dbb6dec7a9137fee3159d8b29cb97bb2..9033786855d721152d4375eb06ce5f7ca2d53770 100644 --- a/starkingdoms-client/src/lib.rs +++ b/starkingdoms-client/src/lib.rs @@ -1,16 +1,16 @@ -use std::ops::Add; -use std::time::Duration; +use crate::ecs::{Camera, Position, Scale, SpriteBundle, SpriteTexture}; +use crate::input::MouseWheelEvent; +use crate::rendering::ui::UiRenderable; +use crate::rendering::App; use bevy_ecs::event::Events; use bevy_ecs::schedule::Schedule; use bevy_ecs::world::World; use egui::Context; +use std::ops::Add; +use std::time::Duration; use tracing::info; use web_time::Instant; use winit::event_loop::{ControlFlow, EventLoop}; -use crate::ecs::{Camera, Position, Scale, SpriteBundle, SpriteTexture}; -use crate::input::MouseWheelEvent; -use crate::rendering::App; -use crate::rendering::ui::UiRenderable; #[cfg(target_arch = "wasm32")] #[path = "wasm/mod.rs"] @@ -23,10 +23,17 @@ pub mod ecs; pub mod input; pub mod rendering; - // Hi, you've found the real main function! This is called AFTER platform-specific initialization code. pub fn start() { - info!("Hello, world! StarKingdoms.TK v{} says hello, running on {}", env!("CARGO_PKG_VERSION"), if cfg!(target_arch = "wasm32") { "wasm" } else { "native" }); + info!( + "Hello, world! StarKingdoms.TK v{} says hello, running on {}", + env!("CARGO_PKG_VERSION"), + if cfg!(target_arch = "wasm32") { + "wasm" + } else { + "native" + } + ); info!("Creating the ECS world..."); let mut world = World::new(); @@ -49,17 +56,20 @@ pub fn start() { world.spawn(SpriteBundle { position: Position { x: 0.0, y: 0.0 }, - scale: Scale { width: 50.0, height: 50.0 }, - texture: SpriteTexture { texture: "happy-tree".to_string() }, + scale: Scale { + width: 50.0, + height: 50.0, + }, + texture: SpriteTexture { + texture: "happy-tree".to_string(), + }, }); - + let event_loop = EventLoop::new().unwrap(); event_loop.set_control_flow(ControlFlow::Poll); - event_loop.run_app(&mut App::new( - world, - update_schedule, - Gui {} - )).unwrap(); + event_loop + .run_app(&mut App::new(world, update_schedule, Gui {})) + .unwrap(); } pub struct Gui {} @@ -72,4 +82,4 @@ impl UiRenderable for Gui { ui.label("A game about floating through space"); }); } -} \ No newline at end of file +} diff --git a/starkingdoms-client/src/native/mod.rs b/starkingdoms-client/src/native/mod.rs index e19eda26493f88b6661f3279f9054f98554b71c0..438b366e36382ed0dac5f6284939a14b41967630 100644 --- a/starkingdoms-client/src/native/mod.rs +++ b/starkingdoms-client/src/native/mod.rs @@ -7,7 +7,7 @@ use wgpu::{Backends, Limits}; /// DO NOT RENAME pub fn entrypoint() { tracing_subscriber::fmt::init(); - + // All done with platform-specific initialization, call back into the common code path crate::start(); -} \ No newline at end of file +} diff --git a/starkingdoms-client/src/rendering/mipmap.rs b/starkingdoms-client/src/rendering/mipmap.rs index 6a10bba47a87f6a01292f5339b77098a6df2b1c4..34c8c33ca87417cc1373a25a52072465379ea2fd 100644 --- a/starkingdoms-client/src/rendering/mipmap.rs +++ b/starkingdoms-client/src/rendering/mipmap.rs @@ -1,7 +1,13 @@ +use crate::rendering::texture::Texture; use std::collections::HashMap; use tracing::debug; -use wgpu::{BindGroupDescriptor, BindGroupEntry, BindingResource, Color, ColorTargetState, ColorWrites, CommandEncoderDescriptor, Device, FilterMode, FragmentState, include_wgsl, LoadOp, Operations, Queue, RenderPassColorAttachment, RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, Sampler, SamplerDescriptor, ShaderModule, StoreOp, TextureFormat, TextureViewDescriptor, VertexState}; -use crate::rendering::texture::Texture; +use wgpu::{ + include_wgsl, BindGroupDescriptor, BindGroupEntry, BindingResource, Color, ColorTargetState, + ColorWrites, CommandEncoderDescriptor, Device, FilterMode, FragmentState, LoadOp, Operations, + Queue, RenderPassColorAttachment, RenderPassDescriptor, RenderPipeline, + RenderPipelineDescriptor, Sampler, SamplerDescriptor, ShaderModule, StoreOp, TextureFormat, + TextureViewDescriptor, VertexState, +}; pub struct MipGenerator { shader: ShaderModule, @@ -11,8 +17,7 @@ pub struct MipGenerator { impl MipGenerator { pub fn new(device: &Device) -> Self { debug!("initializing MipGenerator, compiling shader module"); - let shader = - device.create_shader_module(include_wgsl!("../shaders/text_quad_mips.wgsl")); + let shader = device.create_shader_module(include_wgsl!("../shaders/text_quad_mips.wgsl")); Self { shader, sampler: device.create_sampler(&SamplerDescriptor { @@ -25,33 +30,36 @@ impl MipGenerator { } pub fn generate_mips(&mut self, texture: &Texture, device: &Device, queue: &Queue) { - let pipeline = self.pipelines.entry(texture.texture.format()).or_insert_with(|| { - device.create_render_pipeline(&RenderPipelineDescriptor { - label: Some("MipGenerator format pipeline"), - layout: None, - vertex: VertexState { - module: &self.shader, - entry_point: Some("vs"), - compilation_options: Default::default(), - buffers: &[], - }, - primitive: Default::default(), - depth_stencil: None, - multisample: Default::default(), - fragment: Some(FragmentState { - module: &self.shader, - entry_point: Some("fs"), - compilation_options: Default::default(), - targets: &[Some(ColorTargetState { - format: texture.texture.format(), - blend: None, - write_mask: ColorWrites::default(), - })], - }), - multiview: None, - cache: None, - }) - }); + let pipeline = self + .pipelines + .entry(texture.texture.format()) + .or_insert_with(|| { + device.create_render_pipeline(&RenderPipelineDescriptor { + label: Some("MipGenerator format pipeline"), + layout: None, + vertex: VertexState { + module: &self.shader, + entry_point: Some("vs"), + compilation_options: Default::default(), + buffers: &[], + }, + primitive: Default::default(), + depth_stencil: None, + multisample: Default::default(), + fragment: Some(FragmentState { + module: &self.shader, + entry_point: Some("fs"), + compilation_options: Default::default(), + targets: &[Some(ColorTargetState { + format: texture.texture.format(), + blend: None, + write_mask: ColorWrites::default(), + })], + }), + multiview: None, + cache: None, + }) + }); let mut encoder = device.create_command_encoder(&CommandEncoderDescriptor { label: Some("MipGenerator command encoder"), @@ -123,4 +131,4 @@ impl MipGenerator { let command_buffer = encoder.finish(); queue.submit(std::iter::once(command_buffer)); } -} \ No newline at end of file +} diff --git a/starkingdoms-client/src/rendering/mod.rs b/starkingdoms-client/src/rendering/mod.rs index e9ad2aa66c0408859edbd96dd05aa19c86162de4..1748abadff1dedc1acadb00a94f83b6a63a45ff6 100644 --- a/starkingdoms-client/src/rendering/mod.rs +++ b/starkingdoms-client/src/rendering/mod.rs @@ -1,14 +1,18 @@ +mod mipmap; mod renderer; -pub mod ui; mod texture; -mod mipmap; +pub mod ui; +use crate::input::MouseWheelEvent; +use crate::rendering::renderer::RenderInitRes::{Initialized, NotReadyYet}; +use crate::rendering::renderer::{RenderInitRes, Renderer}; +use crate::rendering::ui::UiRenderable; +use bevy_ecs::schedule::Schedule; +use bevy_ecs::world::World; use std::ops::Add; use std::process::exit; use std::sync::Arc; use std::time::Duration; -use bevy_ecs::schedule::Schedule; -use bevy_ecs::world::World; use tracing::{debug, error, info}; use web_time::Instant; use winit::application::ApplicationHandler; @@ -16,10 +20,6 @@ use winit::dpi::LogicalSize; use winit::event::{MouseScrollDelta, WindowEvent}; use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop}; use winit::window::{Window, WindowId}; -use crate::input::MouseWheelEvent; -use crate::rendering::renderer::{Renderer, RenderInitRes}; -use crate::rendering::renderer::RenderInitRes::{Initialized, NotReadyYet}; -use crate::rendering::ui::UiRenderable; pub struct App { window: Option>, @@ -30,7 +30,7 @@ pub struct App { world: Option, update_schedule: Option, - ui_renderable: Option + ui_renderable: Option, } impl App { @@ -42,15 +42,14 @@ impl App { renderer_rx: None, world: Some(world), update_schedule: Some(update_schedule), - ui_renderable: Some(ui_renderable) + ui_renderable: Some(ui_renderable), } } } impl ApplicationHandler for App { fn resumed(&mut self, event_loop: &ActiveEventLoop) { if self.window.is_none() { - let attributes = Window::default_attributes() - .with_title("StarKingdoms.TK"); + let attributes = Window::default_attributes().with_title("StarKingdoms.TK"); let window = Arc::new(event_loop.create_window(attributes).unwrap()); self.window = Some(window.clone()); @@ -59,14 +58,15 @@ impl ApplicationHandler for App { let update_schedule = self.update_schedule.take().unwrap(); let ui_renderable = self.ui_renderable.take().unwrap(); - #[cfg(not(target_arch = "wasm32"))] { + #[cfg(not(target_arch = "wasm32"))] + { let renderer = pollster::block_on(async move { Renderer::new(window.clone(), world, update_schedule, ui_renderable).await }); match renderer { Initialized(r) => { self.renderer = Some(r); - }, + } NotReadyYet(w, u, t) => { self.world = Some(w); self.update_schedule = Some(u); @@ -74,7 +74,8 @@ impl ApplicationHandler for App { } } } - #[cfg(target_arch = "wasm32")] { + #[cfg(target_arch = "wasm32")] + { use winit::platform::web::WindowExtWebSys; // Add it to the DOM web_sys::window() @@ -89,15 +90,20 @@ impl ApplicationHandler for App { let (tx, rx) = futures::channel::oneshot::channel(); self.renderer_rx = Some(rx); wasm_bindgen_futures::spawn_local(async move { - let renderer = Renderer::new(window.clone(), world, update_schedule, ui_renderable).await; + let renderer = + Renderer::new(window.clone(), world, update_schedule, ui_renderable).await; tx.send(renderer.into()).unwrap(); }); } } - } - fn window_event(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent) { + fn window_event( + &mut self, + event_loop: &ActiveEventLoop, + window_id: WindowId, + event: WindowEvent, + ) { if event == WindowEvent::CloseRequested { info!("Close requested by underlying event system"); event_loop.exit(); @@ -116,41 +122,45 @@ impl ApplicationHandler for App { if new.width > 0 && new.height > 0 { renderer.size = new; renderer.scale_factor = renderer.window.scale_factor(); - renderer.logical_size = LogicalSize::from_physical(renderer.size, renderer.scale_factor); + renderer.logical_size = + LogicalSize::from_physical(renderer.size, renderer.scale_factor); renderer.surface_configuration.width = new.width; renderer.surface_configuration.height = new.height; - renderer.surface.configure(&renderer.device, &renderer.surface_configuration); + renderer + .surface + .configure(&renderer.device, &renderer.surface_configuration); } } - }, + } WindowEvent::ScaleFactorChanged { scale_factor, .. } => { if let Some(renderer) = &mut self.renderer { renderer.scale_factor = scale_factor; - renderer.logical_size = LogicalSize::from_physical(renderer.size, renderer.scale_factor); + renderer.logical_size = + LogicalSize::from_physical(renderer.size, renderer.scale_factor); } - }, + } WindowEvent::MouseWheel { delta, .. } => { if let Some(renderer) = &mut self.renderer { renderer.world.send_event(match delta { - MouseScrollDelta::PixelDelta(pos) => MouseWheelEvent::Pixel { - x: pos.x, - y: pos.y - }, + MouseScrollDelta::PixelDelta(pos) => { + MouseWheelEvent::Pixel { x: pos.x, y: pos.y } + } MouseScrollDelta::LineDelta(x, y) => MouseWheelEvent::Line { x: x as f64, - y: y as f64 - } + y: y as f64, + }, }); } - }, + } _ => {} } } fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) { if let Some(window) = self.window.clone() { - #[cfg(target_arch = "wasm32")] { + #[cfg(target_arch = "wasm32")] + { let mut renderer_rxd = false; if let Some(rx) = self.renderer_rx.as_mut() { if let Ok(Some(renderer)) = rx.try_recv() { @@ -158,7 +168,7 @@ impl ApplicationHandler for App { Initialized(r) => { self.renderer = Some(r); renderer_rxd = true; - }, + } NotReadyYet(w, u, t) => { let (tx, rx) = futures::channel::oneshot::channel(); self.renderer_rx = Some(rx); @@ -175,7 +185,8 @@ impl ApplicationHandler for App { } } - #[cfg(not(target_arch = "wasm32"))] { + #[cfg(not(target_arch = "wasm32"))] + { if self.renderer.is_none() { if let Some(window) = self.window.clone() { let world = self.world.take().unwrap(); @@ -183,13 +194,14 @@ impl ApplicationHandler for App { let ui_renderable = self.ui_renderable.take().unwrap(); let renderer = pollster::block_on(async move { - Renderer::new(window.clone(), world, update_schedule, ui_renderable).await + Renderer::new(window.clone(), world, update_schedule, ui_renderable) + .await }); match renderer { Initialized(r) => { self.renderer = Some(r); - }, + } NotReadyYet(w, u, t) => { self.world = Some(w); self.update_schedule = Some(u); @@ -202,11 +214,15 @@ impl ApplicationHandler for App { } } - let Some(renderer) = &mut self.renderer else { return; }; - + let Some(renderer) = &mut self.renderer else { + return; + }; + renderer.render(); - event_loop.set_control_flow(ControlFlow::WaitUntil(Instant::now().add(Duration::from_secs_f64(1.0 / 60.0)))); + event_loop.set_control_flow(ControlFlow::WaitUntil( + Instant::now().add(Duration::from_secs_f64(1.0 / 60.0)), + )); } } -} \ No newline at end of file +} diff --git a/starkingdoms-client/src/rendering/renderer.rs b/starkingdoms-client/src/rendering/renderer.rs index a818a12167c6035ad4cc4638bea010e9ac5715e3..1e04b23fb120a0e2c5ad56f622ab604a83681ce2 100644 --- a/starkingdoms-client/src/rendering/renderer.rs +++ b/starkingdoms-client/src/rendering/renderer.rs @@ -1,20 +1,27 @@ -use std::collections::HashMap; -use std::fmt::{Debug, Formatter}; -use std::sync::Arc; +use crate::ecs::{Camera, Position, Scale, SpriteTexture}; +use crate::rendering::mipmap::MipGenerator; +use crate::rendering::renderer::RenderInitRes::{Initialized, NotReadyYet}; +use crate::rendering::texture; +use crate::rendering::ui::UiRenderable; use bevy_ecs::schedule::Schedule; use bevy_ecs::world::World; use egui::ViewportId; +use std::collections::HashMap; +use std::fmt::{Debug, Formatter}; +use std::sync::Arc; use tracing::info; use web_time::Instant; -use wgpu::{Adapter, Backends, BindGroupDescriptor, BindGroupEntry, BindingResource, Buffer, BufferDescriptor, BufferUsages, Color, ColorTargetState, CommandEncoderDescriptor, Device, DeviceDescriptor, Features, FragmentState, include_wgsl, Instance, InstanceDescriptor, Limits, LoadOp, Operations, Queue, RenderPassColorAttachment, RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, RequestAdapterOptions, ShaderModule, StoreOp, Surface, TextureViewDescriptor, VertexState}; use wgpu::SurfaceConfiguration; +use wgpu::{ + include_wgsl, Adapter, Backends, BindGroupDescriptor, BindGroupEntry, BindingResource, Buffer, + BufferDescriptor, BufferUsages, Color, ColorTargetState, CommandEncoderDescriptor, Device, + DeviceDescriptor, Features, FragmentState, Instance, InstanceDescriptor, Limits, LoadOp, + Operations, Queue, RenderPassColorAttachment, RenderPassDescriptor, RenderPipeline, + RenderPipelineDescriptor, RequestAdapterOptions, ShaderModule, StoreOp, Surface, + TextureViewDescriptor, VertexState, +}; use winit::dpi::{LogicalSize, PhysicalSize}; use winit::window::Window; -use crate::ecs::{Camera, Position, Scale, SpriteTexture}; -use crate::rendering::mipmap::MipGenerator; -use crate::rendering::renderer::RenderInitRes::{Initialized, NotReadyYet}; -use crate::rendering::texture; -use crate::rendering::ui::UiRenderable; pub struct Renderer { pub last_frame_time: Instant, @@ -45,24 +52,29 @@ pub struct Renderer { pub window: Arc, pub size: PhysicalSize, - pub logical_size: LogicalSize + pub logical_size: LogicalSize, } pub enum RenderInitRes { Initialized(Renderer), - NotReadyYet(World, Schedule, T) + NotReadyYet(World, Schedule, T), } impl Debug for RenderInitRes { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { Initialized(..) => write!(f, "[initialized renderer]"), - NotReadyYet(..) => write!(f, "[pending initialization]") + NotReadyYet(..) => write!(f, "[pending initialization]"), } } } impl Renderer { - pub async fn new(window: Arc, world: World, update_schedule: Schedule, gui_renderable: T) -> RenderInitRes { + pub async fn new( + window: Arc, + world: World, + update_schedule: Schedule, + gui_renderable: T, + ) -> RenderInitRes { let size = window.inner_size(); if size.width == 0 || size.height == 0 { return NotReadyYet(world, update_schedule, gui_renderable); @@ -71,31 +83,43 @@ impl Renderer { // First, create an instance. This is our handle to wgpu, and is the equivalent of navigator.gpu in WebGPU let instance = Instance::new(InstanceDescriptor { backends: Backends::all(), // Select the appropriate backend for the HAL to use. Defined in the platform module, as it's platform-specific - ..Default::default() // Other fields aren't relevant here + ..Default::default() // Other fields aren't relevant here }); // Next, get our render surface let surface = instance.create_surface(window.clone()).unwrap(); // Next, request out adapter - let adapter = instance.request_adapter(&RequestAdapterOptions { - power_preference: Default::default(), // Don't care - force_fallback_adapter: false, // We want a real GPU - compatible_surface: Some(&surface), // Find an adapter that is able to render to our window - }).await.unwrap(); - - let (device, queue) = adapter.request_device(&DeviceDescriptor { - label: Some("Basic render device"), - required_features: Features::default(), - required_limits: Limits::downlevel_webgl2_defaults(), - memory_hints: Default::default(), - }, None).await.unwrap(); + let adapter = instance + .request_adapter(&RequestAdapterOptions { + power_preference: Default::default(), // Don't care + force_fallback_adapter: false, // We want a real GPU + compatible_surface: Some(&surface), // Find an adapter that is able to render to our window + }) + .await + .unwrap(); + + let (device, queue) = adapter + .request_device( + &DeviceDescriptor { + label: Some("Basic render device"), + required_features: Features::default(), + required_limits: Limits::downlevel_webgl2_defaults(), + memory_hints: Default::default(), + }, + None, + ) + .await + .unwrap(); - let format = surface.get_default_config(&adapter, size.width, size.height).unwrap(); + let format = surface + .get_default_config(&adapter, size.width, size.height) + .unwrap(); surface.configure(&device, &format); - let sprite_shader_module = device.create_shader_module(include_wgsl!("../shaders/sprite.wgsl")); + let sprite_shader_module = + device.create_shader_module(include_wgsl!("../shaders/sprite.wgsl")); let sprite_pipeline = device.create_render_pipeline(&RenderPipelineDescriptor { label: Some("Sprite pipeline"), layout: None, @@ -129,15 +153,9 @@ impl Renderer { &window, Some(window.scale_factor() as f32), None, - Some(device.limits().max_texture_dimension_2d as usize) - ); - let gui_renderer = egui_wgpu::Renderer::new( - &device, - format.format, - None, - 1, - false + Some(device.limits().max_texture_dimension_2d as usize), ); + let gui_renderer = egui_wgpu::Renderer::new(&device, format.format, None, 1, false); let uniform_buffer = device.create_buffer(&BufferDescriptor { label: Some("quad uniforms"), @@ -167,7 +185,7 @@ impl Renderer { window, uniform_buffer, size, - surface_configuration: format + surface_configuration: format, }) } @@ -175,16 +193,18 @@ impl Renderer { // update the world self.update_schedule.run(&mut self.world); // update the UI - let egui_output = self.gui_ctx.run( - self.gui_winit.take_egui_input(&self.window), - |ctx| { + let egui_output = self + .gui_ctx + .run(self.gui_winit.take_egui_input(&self.window), |ctx| { self.gui_renderable.render(ctx, &mut self.world) - } - ); - self.gui_winit.handle_platform_output(&self.window, egui_output.platform_output); + }); + self.gui_winit + .handle_platform_output(&self.window, egui_output.platform_output); let output = self.surface.get_current_texture().unwrap(); - let view = output.texture.create_view(&TextureViewDescriptor::default()); + let view = output + .texture + .create_view(&TextureViewDescriptor::default()); let render_pass_descriptor = RenderPassDescriptor { label: Some("basic render pass"), @@ -289,15 +309,24 @@ impl Renderer { // main game rendering done // next up: egui UI rendering for (id, image_delta) in &egui_output.textures_delta.set { - self.gui_renderer.update_texture(&self.device, &self.queue, *id, image_delta); + self.gui_renderer + .update_texture(&self.device, &self.queue, *id, image_delta); } { - let paint_jobs = self.gui_ctx.tessellate(egui_output.shapes, self.scale_factor as f32); + let paint_jobs = self + .gui_ctx + .tessellate(egui_output.shapes, self.scale_factor as f32); let screen_descriptor = egui_wgpu::ScreenDescriptor { size_in_pixels: [self.size.width, self.size.height], - pixels_per_point: self.scale_factor as f32 + pixels_per_point: self.scale_factor as f32, }; - self.gui_renderer.update_buffers(&self.device, &self.queue, &mut encoder, &paint_jobs, &screen_descriptor); + self.gui_renderer.update_buffers( + &self.device, + &self.queue, + &mut encoder, + &paint_jobs, + &screen_descriptor, + ); let render_pass = encoder.begin_render_pass(&RenderPassDescriptor { label: Some("ui render pass"), color_attachments: &[Some(RenderPassColorAttachment { @@ -305,24 +334,24 @@ impl Renderer { resolve_target: None, ops: Operations { load: LoadOp::Load, - store: StoreOp::Store - } + store: StoreOp::Store, + }, })], depth_stencil_attachment: None, timestamp_writes: None, occlusion_query_set: None, }); let mut forgotten_render_pass = render_pass.forget_lifetime(); - self.gui_renderer.render(&mut forgotten_render_pass, &paint_jobs, &screen_descriptor); + self.gui_renderer + .render(&mut forgotten_render_pass, &paint_jobs, &screen_descriptor); for id in egui_output.textures_delta.free { self.gui_renderer.free_texture(&id); } } - let buffer = encoder.finish(); self.queue.submit(std::iter::once(buffer)); output.present(); } -} \ No newline at end of file +} diff --git a/starkingdoms-client/src/rendering/texture.rs b/starkingdoms-client/src/rendering/texture.rs index 48620b2000a173cde1023403abdacc3400401d3d..a83309c6178913df76b0512fa629e446da64dde8 100644 --- a/starkingdoms-client/src/rendering/texture.rs +++ b/starkingdoms-client/src/rendering/texture.rs @@ -1,6 +1,9 @@ -use image::EncodableLayout; -use wgpu::{Device, Extent3d, FilterMode, ImageCopyTexture, ImageDataLayout, Origin3d, Queue, SamplerDescriptor, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages}; use crate::rendering::mipmap::MipGenerator; +use image::EncodableLayout; +use wgpu::{ + Device, Extent3d, FilterMode, ImageCopyTexture, ImageDataLayout, Origin3d, Queue, + SamplerDescriptor, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages, +}; #[derive(Debug)] pub struct Texture { @@ -71,4 +74,4 @@ impl Texture { tex } -} \ No newline at end of file +} diff --git a/starkingdoms-client/src/rendering/ui.rs b/starkingdoms-client/src/rendering/ui.rs index 97bf7f4c550be67c3ee0f0ce947dc5682a10dc97..2aac1846e01424a29f8b9acd3b8c496f762ee8df 100644 --- a/starkingdoms-client/src/rendering/ui.rs +++ b/starkingdoms-client/src/rendering/ui.rs @@ -2,4 +2,4 @@ use bevy_ecs::world::World; pub trait UiRenderable { fn render(&mut self, ctx: &egui::Context, world: &mut World); -} \ No newline at end of file +} diff --git a/starkingdoms-client/src/wasm/mod.rs b/starkingdoms-client/src/wasm/mod.rs index 59d6af455669cf5dd63e231037ce201c46654608..ed321e64d4a7469f5595bf772b0c1c70bad06c54 100644 --- a/starkingdoms-client/src/wasm/mod.rs +++ b/starkingdoms-client/src/wasm/mod.rs @@ -1,9 +1,9 @@ use tracing::Level; use tracing_subscriber::fmt::format::Pretty; use tracing_subscriber::prelude::*; -use wgpu::{Backends, Limits}; +use tracing_web::{performance_layer, MakeWebConsoleWriter}; use wasm_bindgen::prelude::wasm_bindgen; -use tracing_web::{MakeWebConsoleWriter, performance_layer}; +use wgpu::{Backends, Limits}; /// --- IMPORTANT: THIS IS A DUAL TARGET CRATE --- /// THIS WILL ONLY EXECUTE ON WEBASSEMBLY @@ -18,9 +18,8 @@ pub fn entrypoint() { /* ----- Logging setup ----- */ let fmt_layer = tracing_subscriber::fmt::layer() .with_ansi(false) // not supported in browsers - .without_time() // std::time doesn't exist in wasm + .without_time() // std::time doesn't exist in wasm .with_writer(MakeWebConsoleWriter::new().with_max_level(Level::DEBUG)); // wgpu spams the console, and this is slow as hell - let perf_layer = performance_layer() // enable performance tracing .with_details_from_fields(Pretty::default()); // ... with pretty fields @@ -32,4 +31,4 @@ pub fn entrypoint() { // All done with platform-specific initialization, call back into the common code path crate::start(); -} \ No newline at end of file +}