Add compass rose and work around wasm crash

.gitignore

@@ -1,5 +1,4 @@
 **/.DS_Store
-/assets
 /target
 /z_Usefull
 /web/*

Cargo.toml

@@ -27,6 +27,7 @@ directories = "5.0.1"
 async-fs = "2.1.0"
 bevy_web_asset = { git = "https://github.com/oli-obk/bevy_web_asset.git", branch = "user-agent" }
 big_space = "0.4.0"
+bevy_embedded_assets = "0.9.1"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 web-sys = { version = "0.3.22", default-features = false, features = [

assets/8k.md

@@ -0,0 +1 @@
+Source: https://www.solarsystemscope.com/textures/

assets/compass.md

@@ -0,0 +1 @@
+Source: https://openclipart.org/detail/233063/compass-rose-2

src/lib.rs

@@ -4,8 +4,11 @@ use std::f32::consts::FRAC_PI_2;
 
 use bevy::{
     diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin},
+    ecs::system::SystemParam,
+    pbr::NotShadowCaster,
     prelude::*,
 };
+use bevy_embedded_assets::EmbeddedAssetPlugin;
 use bevy_flycam::{FlyCam, MovementSettings};
 #[cfg(all(feature = "xr", not(any(target_os = "macos", target_arch = "wasm32"))))]
 use bevy_oxr::xr_input::trackers::OpenXRTrackingRoot;
@@ -86,6 +89,8 @@ pub fn main() {
     app.add_plugins(HttpAssetReaderPlugin {
         base_url: "gltiles.osm2world.org/glb/".into(),
     });
+    // Offer assets via `embedded://`
+    app.add_plugins(EmbeddedAssetPlugin::default());
     app.add_plugins(bevy_web_asset::WebAssetPlugin {
         user_agent: Some("osmeta 0.1.0".into()),
     });
@@ -128,6 +133,7 @@ pub fn main() {
             ),
         )
         .add_systems(Update, update_camera_orientations)
+        .add_systems(PostUpdate, reposition_compass)
         .run();
 }
 
@@ -214,19 +220,10 @@ fn recompute_view_distance(
     }
 }
 
-fn get_main_camera_position(
-    xr_pos: Query<(&Transform, &GalacticGrid), (With<OpenXRTrackingRoot>, Without<FlyCam>)>,
-    flycam_pos: Query<(&Transform, &GalacticGrid), (With<FlyCam>, Without<OpenXRTrackingRoot>)>,
-    view_distance: Res<ViewDistance>,
-    space: Res<FloatingOriginSettings>,
-) -> (TileIndex, Vec2) {
-    let (pos, grid) = if let Ok(xr_pos) = xr_pos.get_single() {
-        xr_pos
-    } else {
-        flycam_pos.single()
-    };
+fn get_main_camera_position(player: Player, view_distance: Res<ViewDistance>) -> (TileIndex, Vec2) {
+    let player = player.pos();
 
-    let pos = space.grid_position_double(grid, pos);
+    let pos = player.pos();
     let origin = GeoPos::from_cartesian(pos);
     let tile_size = origin.tile_size(TILE_ZOOM);
     let radius = view_distance.0 / tile_size + 0.5;
@@ -235,6 +232,108 @@ fn get_main_camera_position(
     (origin.as_tile_index(), radius)
 }
 
+#[derive(Component)]
+struct Compass;
+
+#[derive(SystemParam)]
+struct Player<'w, 's> {
+    xr_pos: Query<
+        'w,
+        's,
+        (&'static Transform, &'static GalacticGrid),
+        (With<OpenXRTrackingRoot>, Without<FlyCam>, Without<Compass>),
+    >,
+    flycam_pos: Query<
+        'w,
+        's,
+        (&'static Transform, &'static GalacticGrid),
+        (With<FlyCam>, Without<OpenXRTrackingRoot>, Without<Compass>),
+    >,
+    space: Res<'w, FloatingOriginSettings>,
+}
+
+struct PlayerPosition<'a> {
+    transform: Transform,
+    grid: GalacticGrid,
+    space: &'a FloatingOriginSettings,
+}
+
+impl PlayerPosition<'_> {
+    pub fn pos(&self) -> DVec3 {
+        self.space.grid_position_double(&self.grid, &self.transform)
+    }
+    pub fn directions(&self) -> Directions {
+        let up = self.pos().normalize().as_vec3();
+        let west = Vec3::Z.cross(up);
+        let north = up.cross(west);
+        Directions { up, north, west }
+    }
+}
+
+struct Directions {
+    up: Vec3,
+    north: Vec3,
+    west: Vec3,
+}
+
+impl<'w, 's> Player<'w, 's> {
+    pub fn pos(&self) -> PlayerPosition<'_> {
+        let (&transform, &grid) = if let Ok(xr_pos) = self.xr_pos.get_single() {
+            xr_pos
+        } else {
+            self.flycam_pos.single()
+        };
+        PlayerPosition {
+            transform,
+            grid,
+            space: &self.space,
+        }
+    }
+}
+
+fn reposition_compass(
+    mut compass: Query<
+        (&mut Transform, &mut GalacticGrid),
+        (With<Compass>, Without<FlyCam>, Without<OpenXRTrackingRoot>),
+    >,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    server: Res<AssetServer>,
+    player: Player,
+) {
+    if let Ok((mut pos, mut grid)) = compass.get_single_mut() {
+        let player = player.pos();
+        let directions = player.directions();
+        pos.translation = player.transform.translation - directions.up * 5.;
+        *grid = player.grid;
+        pos.look_to(directions.north, directions.up)
+    } else {
+        let mesh = shape::Plane::default();
+        let mesh = meshes.add(mesh.into());
+        let image = server.load("embedded://compass.png");
+        let material = materials.add(StandardMaterial {
+            base_color_texture: Some(image),
+            unlit: true,
+            cull_mode: None,
+            perceptual_roughness: 1.0,
+            fog_enabled: false,
+            alpha_mode: AlphaMode::Blend,
+            ..default()
+        });
+        commands.spawn((
+            PbrBundle {
+                mesh,
+                material,
+                ..default()
+            },
+            GalacticGrid::ZERO,
+            Compass,
+            NotShadowCaster,
+        ));
+    }
+}
+
 fn update_camera_orientations(
     mut movement_settings: ResMut<MovementSettings>,
     fly_cam: Query<(&Transform, &GalacticGrid), With<FlyCam>>,

src/sun.rs

@@ -89,7 +89,7 @@ fn setup(
     );
 
     // Stars
-    let image = server.load("https://www.solarsystemscope.com/textures/download/2k_stars.jpg");
+    let image = server.load("embedded://8k_stars.jpg");
     commands.spawn((
         PbrBundle {
             mesh: mesh.clone(),
@@ -111,8 +111,7 @@ fn setup(
     ));
 
     // Clouds visible from earth and space
-    let image =
-        server.load("https://www.solarsystemscope.com/textures/download/2k_earth_clouds.jpg");
+    let image = server.load("embedded://8k_earth_clouds.jpg");
     commands.spawn((
         PbrBundle {
             mesh: mesh.clone(),
@@ -150,8 +149,7 @@ fn setup(
         GalacticGrid::ZERO,
     ));
 
-    let image =
-        server.load("https://www.solarsystemscope.com/textures/download/2k_earth_daymap.jpg");
+    let image = server.load("embedded://8k_earth_daymap.jpg");
 
     // ground
     commands.spawn((
@@ -174,7 +172,7 @@ fn setup(
         NeedsTextureSetToRepeat(image),
     ));
 
-    let image = server.load("https://www.solarsystemscope.com/textures/download/2k_moon.jpg");
+    let image = server.load("embedded://8k_moon.jpg");
 
     // moon
     commands.spawn((
@@ -206,23 +204,29 @@ fn set_texture_transparent(
     textures: Query<(Entity, &NeedsTextureTransparencyEqualToRed)>,
 ) {
     for (entity, NeedsTextureTransparencyEqualToRed(handle)) in textures.iter() {
-        info!("making clouds transparent");
         use bevy::asset::LoadState::*;
-        if let Loaded | Failed = server.get_load_state(handle).unwrap() {
-            let Some(image) = images.get_mut(handle) else {
-                unreachable!()
-            };
-            info!("clouds made transparent");
-            *image = image.convert(TextureFormat::Rgba8UnormSrgb).unwrap();
-            for chunk in image.data.chunks_exact_mut(4) {
-                let [r, _g, _b, a] = chunk else {
+        match server.get_load_state(handle).unwrap() {
+            Loaded => {
+                let Some(image) = images.get_mut(handle) else {
                     unreachable!()
                 };
-                *a = *r;
+                *image = image.convert(TextureFormat::Rgba8UnormSrgb).unwrap();
+                for chunk in image.data.chunks_exact_mut(4) {
+                    let [r, _g, _b, a] = chunk else {
+                        unreachable!()
+                    };
+                    *a = *r;
+                }
+                commands
+                    .entity(entity)
+                    .remove::<NeedsTextureTransparencyEqualToRed>();
             }
-            commands
-                .entity(entity)
-                .remove::<NeedsTextureTransparencyEqualToRed>();
+            Failed => {
+                commands
+                    .entity(entity)
+                    .remove::<NeedsTextureTransparencyEqualToRed>();
+            }
+            _ => (),
         }
     }
 }
@@ -235,13 +239,18 @@ fn set_texture_repeat(
 ) {
     for (entity, NeedsTextureSetToRepeat(handle)) in textures.iter() {
         use bevy::asset::LoadState::*;
-        if let Loaded | Failed = server.get_load_state(handle).unwrap() {
-            let Some(image) = images.get_mut(handle) else {
-                unreachable!()
-            };
-            info!("texture set to repeat");
-            image.sampler = repeat_sampler();
-            commands.entity(entity).remove::<NeedsTextureSetToRepeat>();
+        match server.get_load_state(handle).unwrap() {
+            Loaded => {
+                let Some(image) = images.get_mut(handle) else {
+                    unreachable!()
+                };
+                image.sampler = repeat_sampler();
+                commands.entity(entity).remove::<NeedsTextureSetToRepeat>();
+            }
+            Failed => {
+                commands.entity(entity).remove::<NeedsTextureSetToRepeat>();
+            }
+            _ => (),
         }
     }
 }