ui testing

Building prefab loading

engine/asset_loader/Cargo.toml

@@ -9,5 +9,5 @@ edition = "2021"
 [dependencies]
 serde = "1.0.204"
 serde_json = "1.0.120"
-bevy = "0.14.2"
+bevy = "0.15.1"
 ron = "0.8.1"

engine/asset_loader/src/lib.rs

@@ -1 +1 @@
-pub mod macros;
+pub mod macros;

engine/asset_loader/src/macros.rs

@@ -29,12 +29,12 @@ macro_rules! create_asset_loader {
 
 			type Error = String;
 
-			async fn load<'a>(
+			async fn load(
-				&'a self,
+		        &self,
-				reader: &'a mut Reader<'_>,
+				reader: & mut dyn bevy::asset::io::Reader,
-				_settings: &'a Self::Settings,
+				_: &Self::Settings,
-				load_context: &'a mut LoadContext<'_>,
+				load_context: &mut LoadContext<'_>,
-			) -> Result<Self::Asset, Self::Error> {
+		    ) -> Result<Self::Asset, Self::Error> {
 				let mut bytes = Vec::new();
 				let read_result = reader.read_to_end(&mut bytes).await;
 				if read_result.is_err() {

engine/asset_loader_proc/Cargo.toml

@@ -9,5 +9,5 @@ proc-macro = true
 [dependencies]
 serde = "1.0.204"
 serde_json = "1.0.120"
-bevy = "0.14.2"
+bevy = "0.15.1"
 ron = "0.8.1"

engine/world_generation/Cargo.toml

@@ -6,14 +6,14 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.14.2"
+bevy = "0.15.1"
 noise = "0.9.0"
 serde = { version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.115"
 asset_loader = { path = "../asset_loader" }
 rayon = "1.10.0"
-bevy-inspector-egui = "0.25.0"
+bevy-inspector-egui = "0.28.1"
-bevy_asset_loader = { version = "0.21.0", features = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

engine/world_generation/src/map/map_utils.rs

@@ -1,16 +1,12 @@
 use std::ops::Add;
 
-use bevy::{math::VectorSpace, prelude::*};
+use bevy::{asset::AssetLoader, math::VectorSpace, prelude::*};
 use image::ImageBuffer;
 use rayon::prelude::*;
 
 use crate::hex_utils::HexCoord;
 
-use super::{
+use super::{biome_map::BiomeMap, chunk::Chunk, map::Map};
-	biome_map::BiomeMap,
-	chunk::Chunk,
-	map::Map,
-};
 
 pub fn render_image(
 	size: UVec2,
@@ -40,7 +36,7 @@ pub fn update_image(
 		let idx = (y * w + x) as usize;
 		let v = data[idx];
 		let t = v.remap(min, max, 0.0, 1.0);
-		let col = LinearRgba::lerp(&color1, color2, t);
+		let col = LinearRgba::lerp(color1, color2, t);
 		*pixel = to_pixel(&col);
 	});
 }
@@ -95,10 +91,10 @@ fn get_height_color_blend(base_color: Hsla, height: f32, height2: f32, smooth: f
 			d /= smooth;
 			if d > 0.0 {
 				let c2: LinearRgba = color.with_lightness(color.lightness + 0.1).into();
-				color = LinearRgba::lerp(&color.into(), c2, d).into();
+				color = LinearRgba::lerp(color.into(), c2, d).into();
 			} else {
 				let c2: LinearRgba = color.with_lightness(color.lightness - 0.1).into();
-				color = LinearRgba::lerp(&color.into(), c2, d.abs()).into();
+				color = LinearRgba::lerp(color.into(), c2, d.abs()).into();
 			}
 		}
 	}

game/buildings/Cargo.toml

@@ -6,15 +6,15 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.14.2"
+bevy = "0.15.1"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
-bevy_rapier3d = "0.27.0"
+bevy_rapier3d = "0.28.0"
 serde = { version = "1.0.204", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
 serde_json = "1.0.120"
 ron = "0.8.1"
-bevy_asset_loader = { version = "0.21.0", features = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

game/buildings/src/assets/building_asset.rs

@@ -1,14 +1,18 @@
 use asset_loader::create_asset_loader;
-use bevy::prelude::*;
+use bevy::{
+	gltf::{GltfMesh, GltfNode},
+	prelude::*,
+};
 use serde::{Deserialize, Serialize};
-use shared::identifiers::ResourceIdentifier;
+use shared::{component_defination::ComponentDefination, identifiers::ResourceIdentifier, prefab_defination::*};
 
 use crate::{
 	buildings::{
-		basic_building::BasicBuildingInfo, factory_building::FactoryBuildingInfo,
+		conduit_building::ResourceConduitInfo, factory_building::FactoryBuildingInfo,
 		resource_gathering::ResourceGatheringBuildingInfo,
 	},
 	footprint::BuildingFootprint,
+	prelude::Building,
 };
 
 #[derive(Asset, TypePath, Debug, Serialize, Deserialize)]
@@ -18,7 +22,8 @@ pub struct BuildingAsset {
 	pub footprint: BuildingFootprint,
 	pub prefab_path: String,
 	#[serde(skip)]
-	pub prefab: Handle<Scene>,
+	pub prefab: Handle<Gltf>,
+	pub base_mesh_path: String,
 
 	pub cost: Vec<ResourceIdentifier>,
 	pub consumption: Vec<ResourceIdentifier>,
@@ -27,7 +32,90 @@ pub struct BuildingAsset {
 	pub health: u32,
 
 	pub building_type: BuildingType,
-	pub animations: Vec<AnimationComponent>,
+	pub components: Option<Vec<ComponentDefination>>,
+}
+
+impl BuildingAsset {
+	pub fn spawn(
+		&self,
+		pos: Vec3,
+		rot: Quat,
+		gltf: &Gltf,
+		commands: &mut Commands,
+		meshes: &Assets<GltfMesh>,
+		nodes: &Assets<GltfNode>,
+	) -> Option<Entity> {
+		let base_node = &gltf.named_nodes[&self.base_mesh_path.clone().into_boxed_str()];
+		if let Some(node) = nodes.get(base_node.id()) {
+			if let Some(mesh_handle) = &node.mesh {
+				if let Some(gltf_mesh) = meshes.get(mesh_handle.id()) {
+					let (mesh, mat) = gltf_mesh.unpack();
+					let mut entity = commands.spawn((
+						Mesh3d(mesh),
+						MeshMaterial3d(mat),
+						Transform::from_translation(pos).with_rotation(rot),
+						Building,
+					));
+					entity.with_children(|b| {
+						for child in &node.children {
+							let child_node = nodes.get(child.id());
+							if child_node.is_none() {
+								continue;
+							}
+							self.process_node(child_node.unwrap(), meshes, nodes, b, &node.name);
+						}
+					});
+					if let Some(component) = self.get_component_def(&format!("/{0}", &node.name)) {
+						component.apply(&mut entity);
+					}
+					return Some(entity.id());
+				}
+			}
+		}
+		return None;
+	}
+
+	fn process_node(
+		&self,
+		node: &GltfNode,
+		meshes: &Assets<GltfMesh>,
+		nodes: &Assets<GltfNode>,
+		commands: &mut ChildBuilder,
+		parent: &String,
+	) -> Option<Entity> {
+		let path = format!("{0}/{1}", parent, node.name);
+		if let Some(mesh) = &node.mesh {
+			if let Some(gltf_mesh) = meshes.get(mesh.id()) {
+				let (mesh, mat) = gltf_mesh.unpack();
+				let mut entity = commands.spawn((Mesh3d(mesh), MeshMaterial3d(mat), node.transform, Building));
+				entity.with_children(|b| {
+					for child in &node.children {
+						let child_node = nodes.get(child.id());
+						if child_node.is_none() {
+							continue;
+						}
+						self.process_node(child_node.unwrap(), meshes, nodes, b, &path);
+					}
+				});
+				if let Some(component) = self.get_component_def(&path) {
+					component.apply(&mut entity);
+				}
+				return Some(entity.id());
+			}
+		}
+		return None;
+	}
+
+	fn get_component_def(&self, path: &String) -> Option<&ComponentDefination> {
+		if let Some(components) = &self.components {
+			for c in components {
+				if c.path.ends_with(path) {
+					return Some(c);
+				}
+			}
+		}
+		return None;
+	}
 }
 
 #[derive(Serialize, Deserialize, Debug, TypePath)]
@@ -35,13 +123,9 @@ pub enum BuildingType {
 	Basic,
 	Gathering(ResourceGatheringBuildingInfo),
 	FactoryBuildingInfo(FactoryBuildingInfo),
+	ResourceConduit(ResourceConduitInfo),
 }
 
-#[derive(Serialize, Deserialize, Debug, Reflect)]
-pub enum AnimationComponent {
-	Rotation,
-	Slider,
-}
 create_asset_loader!(
 	BuildingAssetPlugin,
 	BuildingAssetLoader,

game/buildings/src/building_plugin.rs

@@ -1,6 +1,11 @@
 use std::f32::consts::E;
 
-use bevy::{ecs::world::CommandQueue, prelude::*, window::PrimaryWindow};
+use bevy::{
+	ecs::world::CommandQueue,
+	gltf::{GltfMesh, GltfNode},
+	prelude::*,
+	window::PrimaryWindow,
+};
 use bevy_asset_loader::loading_state::{
 	config::{ConfigureLoadingState, LoadingStateConfig},
 	LoadingStateAppExt,
@@ -87,7 +92,6 @@ fn hq_placement(
 	mut build_queue: ResMut<BuildQueue>,
 	mut next_state: ResMut<NextState<GameplayState>>,
 ) {
-
 	if let Some(contact) = tile_under_cursor.0 {
 		let positions = map.hex_select(&contact.tile, 3, true, |pos, h, _| pos.to_world(h));
 		show_indicators(positions, &mut commands, &indicator);
@@ -106,12 +110,9 @@ fn hq_placement(
 fn show_indicators(positions: Vec<Vec3>, commands: &mut Commands, indicator: &IndicatorCube) {
 	for p in positions {
 		commands.spawn((
-			PbrBundle {
+			Mesh3d(indicator.0.clone()),
-				mesh: indicator.0.clone(),
+			MeshMaterial3d(indicator.1.clone()),
-				material: indicator.1.clone(),
+			Transform::from_translation(p),
-				transform: Transform::from_translation(p),
-				..default()
-			},
 			Despawn,
 		));
 	}
@@ -122,6 +123,9 @@ fn process_build_queue(
 	mut commands: Commands,
 	db: Res<BuildingDatabase>,
 	building_assets: Res<Assets<BuildingAsset>>,
+	gltf_assets: Res<Assets<Gltf>>,
+	gltf_meshes: Res<Assets<GltfMesh>>,
+	gltf_nodes: Res<Assets<GltfNode>>,
 	mut building_map: ResMut<BuildingMap>,
 	heightmap: Res<Map>,
 ) {
@@ -130,16 +134,21 @@ fn process_build_queue(
 		if let Some(building) = building_assets.get(handle.id()) {
 			let h = heightmap.sample_height(&item.pos);
 			println!("Spawning {} at {}", building.name, item.pos);
-			let e = commands.spawn((
+			if let Some(gltf) = gltf_assets.get(building.prefab.id()) {
-				SceneBundle {
+				let e = building.spawn(
-					scene: building.prefab.clone(),
+					item.pos.to_world(h),
-					transform: Transform::from_translation(item.pos.to_world(h)),
+					Quat::IDENTITY,
-					..Default::default()
+					gltf,
-				},
+					&mut commands,
-				Building,
+					&gltf_meshes,
-			));
+					&gltf_nodes,
-
+				);
-			building_map.add_building(BuildingEntry::new(item.pos, e.id()));
+				if let Some(b) = e {
+					building_map.add_building(BuildingEntry::new(item.pos, b));
+				}
+			} else {
+				warn!("Failed to spawn building");
+			}
 		}
 	}
 	queue.queue.clear();

game/buildings/src/buildings/basic_building.rs

@@ -1,4 +1,3 @@
 use serde::{Deserialize, Serialize};
-use shared::identifiers::ResourceIdentifier;
 #[derive(Serialize, Deserialize, Debug)]
 pub struct BasicBuildingInfo {}

game/buildings/src/buildings/conduit_building.rs

@@ -0,0 +1,6 @@
+use serde::{Deserialize, Serialize};
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ResourceConduitInfo {
+	pub range: usize,
+	pub connection_range: usize,
+}

game/buildings/src/buildings/mod.rs

@@ -1,4 +1,5 @@
-pub mod resource_gathering;
 pub mod basic_building;
+pub mod conduit_building;
 pub mod factory_building;
+pub mod resource_gathering;
 pub mod tech_building;

game/main/Cargo.toml

@@ -7,12 +7,12 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = { version = "0.14.2", features = ["file_watcher"] }
+bevy = { version = "0.15.1", features = ["file_watcher"] }
-bevy-inspector-egui = "0.25.0"
+bevy-inspector-egui = "0.28.1"
-iyes_perf_ui = "0.3.0"
+# iyes_perf_ui = "0.3.0"
 noise = "0.8.2"
 world_generation = { path = "../../engine/world_generation" }
-bevy_rapier3d = { version = "0.27.0", features = [ 
+bevy_rapier3d = { version = "0.28.0", features = [
 	"simd-stable",
 	"parallel",
 	"debug-render-3d",
@@ -21,13 +21,13 @@ rayon = "1.10.0"
 buildings = { path = "../buildings" }
 units = { path = "../units" }
 shared = { path = "../shared" }
-bevy_asset_loader = { version = "0.21.0", features = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
 ron = "0.8.1"
 image = "0.25.2"
-bevy_lunex = "0.2.4"
+# bevy_lunex = "0.2.4"
 
 [features]
 tracing = [

game/main/build.rs

@@ -13,6 +13,10 @@ where
 
 	for path in fs::read_dir(from).unwrap() {
 		let path = path.unwrap().path();
+		println!("{path:?}");
+		if path.starts_with("assets/raw_assets") {
+			continue;
+		}
 		let to = to.clone().join(path.file_name().unwrap());
 
 		if path.is_file() {

game/main/src/camera_system/camera_plugin.rs

@@ -1,10 +1,8 @@
-use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin};
+use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin, TemporalAntiAliasing};
 use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::input::mouse::{MouseMotion, MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
-use bevy::render::view::RenderLayers;
 use bevy::window::{CursorGrabMode, PrimaryWindow};
-use bevy_lunex::prelude::MainUi;
 use shared::sets::GameplaySet;
 use shared::tags::MainCamera;
 use world_generation::hex_utils::HexCoord;
@@ -22,13 +20,9 @@ impl Plugin for PhosCameraPlugin {
 
 		app.add_systems(PreStartup, setup);
 
-		// app.add_systems(Update, rts_camera_system.in_set(GameplaySet));
-		// app.add_systems(PostUpdate, limit_camera_bounds.in_set(GameplaySet));
 		app.add_systems(Update, orbit_camera_upate.in_set(GameplaySet));
 
 		app.add_systems(Update, init_bounds.run_if(in_state(GeneratorState::SpawnMap)));
-		//Free Cam
-		//app.add_systems(Update, (grab_mouse, (update_camera, update_camera_mouse).chain()));
 
 		app.add_plugins(TemporalAntiAliasPlugin);
 	}
@@ -50,23 +44,21 @@ fn init_bounds(
 		});
 }
 
-fn setup(mut commands: Commands, mut msaa: ResMut<Msaa>) {
+fn setup(mut commands: Commands) {
 	commands
 		.spawn((
-			Camera3dBundle {
+			Camera3d::default(),
-				transform: Transform::from_xyz(0., 30., 0.).looking_to(Vec3::NEG_Z, Vec3::Y),
+			Transform::from_xyz(0., 30., 0.).looking_to(Vec3::NEG_Z, Vec3::Y),
-				..default()
-			},
 			PhosCamera::default(),
 			MainCamera,
 			DepthPrepass,
 			PhosOrbitCamera::default(),
-			MainUi,
+			TemporalAntiAliasing::default(),
 		))
-		.insert(TemporalAntiAliasBundle::default())
+		.insert(Msaa::Off);
-		.insert(RenderLayers::layer(0));
+	// .insert(RenderLayers::layer(0))
 
-	*msaa = Msaa::Off;
+	// *msaa = Msaa::Off;
 }
 
 fn orbit_camera_upate(
@@ -94,24 +86,24 @@ fn orbit_camera_upate(
 		for e in mouse_motion.read() {
 			orbit_move += e.delta;
 		}
-		orbit_move *= config.pan_speed * time.delta_seconds() * -1.0;
+		orbit_move *= config.pan_speed * time.delta_secs() * -1.0;
 		let rot_y = Quat::from_axis_angle(Vec3::Y, orbit_move.x);
 		let right = orbit.forward.cross(Vec3::Y).normalize();
 		let rot_x = Quat::from_axis_angle(right, orbit_move.y);
 		orbit.forward = rot_x * rot_y * orbit.forward;
 		// orbit.forward.y = orbit.forward.y.clamp(-0.9, 0.0);
 		orbit.forward = orbit.forward.normalize();
-		window.cursor.grab_mode = CursorGrabMode::Locked;
+		window.cursor_options.grab_mode = CursorGrabMode::Locked;
-		window.cursor.visible = false;
+		window.cursor_options.visible = false;
 	} else {
-		window.cursor.grab_mode = CursorGrabMode::None;
+		window.cursor_options.grab_mode = CursorGrabMode::None;
-		window.cursor.visible = true;
+		window.cursor_options.visible = true;
 	}
 	if key.pressed(KeyCode::KeyE) {
-		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(config.speed) * time.delta_seconds());
+		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(config.speed) * time.delta_secs());
 		orbit.forward = rot * orbit.forward;
 	} else if key.pressed(KeyCode::KeyQ) {
-		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(-config.speed) * time.delta_seconds());
+		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(-config.speed) * time.delta_secs());
 		orbit.forward = rot * orbit.forward;
 	}
 
@@ -144,7 +136,7 @@ fn orbit_camera_upate(
 			gizmos.arrow(orbit.target, orbit.target + move_fwd, LinearRgba::WHITE.with_alpha(0.5));
 			gizmos.arrow(orbit.target, orbit.target - (move_rot * cam_move), LinearRgba::BLUE);
 		}
-		orbit.target -= (move_rot * cam_move) * move_speed * time.delta_seconds();
+		orbit.target -= (move_rot * cam_move) * move_speed * time.delta_secs();
 		orbit.target.y = sample_ground(orbit.target, &map);
 
 		orbit.target.x = orbit.target.x.clamp(bounds.min.x, bounds.max.x);
@@ -159,7 +151,7 @@ fn orbit_camera_upate(
 		}
 	}
 
-	orbit.distance -= scroll * time.delta_seconds() * config.zoom_speed;
+	orbit.distance -= scroll * time.delta_secs() * config.zoom_speed;
 	orbit.distance = orbit.distance.clamp(config.min_height, config.max_height);
 
 	// let ground_below_cam = sample_ground(cam_pos, &map) + config.min_height;

game/main/src/main.rs

@@ -1,8 +1,8 @@
 use std::env;
 
+use bevy::image::{ImageAddressMode, ImageFilterMode, ImageSamplerDescriptor};
 use bevy::pbr::wireframe::WireframePlugin;
 use bevy::prelude::*;
-use bevy::render::texture::{ImageAddressMode, ImageFilterMode, ImageSamplerDescriptor};
 use bevy::window::PresentMode;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 use phos::PhosGamePlugin;

game/main/src/map_rendering/chunk_rebuild.rs

@@ -73,14 +73,14 @@ fn chunk_rebuilder(
 }
 
 fn collider_task_resolver(
-	mut chunks: Query<(&mut ChunkRebuildTask, &Handle<Mesh>), With<PhosChunk>>,
+	mut chunks: Query<(&mut ChunkRebuildTask, &Mesh3d), With<PhosChunk>>,
 	mut commands: Commands,
 	mut meshes: ResMut<Assets<Mesh>>,
 ) {
 	for (mut task, mesh_handle) in &mut chunks {
 		if let Some((mut c, mesh)) = futures::check_ready(&mut task.task) {
 			commands.append(&mut c);
-			meshes.insert(mesh_handle, mesh);
+			meshes.insert(mesh_handle.id(), mesh);
 		}
 	}
 }

game/main/src/map_rendering/map_init.rs

@@ -252,12 +252,9 @@ fn spawn_map(
 			// let mesh_handle = meshes.a
 			let chunk = commands
 				.spawn((
-					MaterialMeshBundle {
+					Mesh3d(meshes.add(chunk_mesh)),
-						mesh: meshes.add(chunk_mesh),
+					MeshMaterial3d(atlas.chunk_material_handle.clone()),
-						material: atlas.chunk_material_handle.clone(),
+					Transform::from_translation(pos),
-						transform: Transform::from_translation(pos),
-						..default()
-					},
 					PhosChunk::new(index),
 					RenderDistanceVisibility::default().with_offset(visibility_offset),
 					collider,
@@ -265,12 +262,9 @@ fn spawn_map(
 				.id();
 			let water = commands
 				.spawn((
-					MaterialMeshBundle {
+					Mesh3d(meshes.add(water_mesh)),
-						mesh: meshes.add(water_mesh),
+					MeshMaterial3d(atlas.water_material.clone()),
-						material: atlas.water_material.clone(),
+					Transform::from_translation(pos),
-						transform: Transform::from_translation(pos),
-						..default()
-					},
 					PhosChunk::new(index),
 					NotShadowCaster,
 					RenderDistanceVisibility::default().with_offset(visibility_offset),

game/main/src/phos.rs

@@ -1,7 +1,7 @@
 use crate::camera_system::components::PhosCamera;
 use crate::map_rendering::map_init::MapInitPlugin;
 use crate::map_rendering::render_distance_system::RenderDistancePlugin;
-use crate::ui::game::build_ui::BuildUiPlugin;
+use crate::ui::build_ui::BuildUIPlugin;
 use crate::utlis::editor_plugin::EditorPlugin;
 use crate::utlis::tile_selection_plugin::TileSelectionPlugin;
 use crate::{camera_system::camera_plugin::PhosCameraPlugin, utlis::debug_plugin::DebugPlugin};
@@ -14,7 +14,8 @@ use bevy_rapier3d::dynamics::{Ccd, RigidBody, Velocity};
 use bevy_rapier3d::geometry::Collider;
 use bevy_rapier3d::plugin::{NoUserData, RapierPhysicsPlugin};
 use buildings::BuildingPugin;
-use iyes_perf_ui::prelude::*;
+// use iyes_perf_ui::prelude::*;
+use shared::animation_plugin::SimpleAnimationPlugin;
 use shared::sets::GameplaySet;
 use shared::states::{GameplayState, MenuState};
 use shared::{despawn::DespawnPuglin, states::AssetLoadState};
@@ -38,7 +39,8 @@ impl Plugin for PhosGamePlugin {
 			MapInitPlugin,
 			RenderDistancePlugin,
 			BuildingPugin,
-			BuildUiPlugin,
+			BuildUIPlugin,
+			SimpleAnimationPlugin,
 			UnitsPlugin,
 			DespawnPuglin,
 			TileSelectionPlugin,
@@ -59,8 +61,8 @@ impl Plugin for PhosGamePlugin {
 		//Perf UI
 		app.add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
 			.add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
-			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin)
+			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin);
-			.add_plugins(PerfUiPlugin);
+		// .add_plugins(PerfUiPlugin);
 
 		//Physics
 		app.add_plugins(RapierPhysicsPlugin::<NoUserData>::default());
@@ -76,52 +78,51 @@ impl Plugin for PhosGamePlugin {
 fn configure_gameplay_set(app: &mut App) {
 	app.configure_sets(
 		Update,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		PreUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		PostUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 
 	app.configure_sets(
 		FixedUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		FixedPreUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 	app.configure_sets(
 		FixedPostUpdate,
-		GameplaySet.run_if(in_state(GeneratorState::Idle).and_then(in_state(MenuState::InGame))),
+		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
 	);
 }
 
 fn init_game(mut commands: Commands, mut materials: ResMut<Assets<StandardMaterial>>) {
-	commands.spawn((
+	// commands.spawn((
-		PerfUiRoot::default(),
+	// 	PerfUiRoot::default(),
-		PerfUiEntryFPS::default(),
+	// 	PerfUiEntryFPS::default(),
-		PerfUiEntryFPSWorst::default(),
+	// 	PerfUiEntryFPSWorst::default(),
-		PerfUiEntryFrameTime::default(),
+	// 	PerfUiEntryFrameTime::default(),
-		PerfUiEntryFrameTimeWorst::default(),
+	// 	PerfUiEntryFrameTimeWorst::default(),
-	));
+	// ));
 
-	commands.spawn(DirectionalLightBundle {
+	commands.spawn((
-		directional_light: DirectionalLight {
+		DirectionalLight {
 			shadows_enabled: true,
 			..default()
 		},
-		cascade_shadow_config: CascadeShadowConfig {
+		CascadeShadowConfig {
 			bounds: vec![200., 400., 600., 800.],
 			..default()
 		},
-		transform: Transform::from_xyz(500., 260.0, 500.).looking_at(Vec3::ZERO, Vec3::Y),
+		Transform::from_xyz(500., 260.0, 500.).looking_at(Vec3::ZERO, Vec3::Y),
-		..default()
+	));
-	});
 
 	let sphere_mat = StandardMaterial {
 		base_color: Color::srgb(1., 1., 0.),
@@ -144,12 +145,9 @@ fn spawn_sphere(
 	if keyboard_input.just_pressed(KeyCode::KeyF) {
 		let cam_transform = cam.single();
 		commands.spawn((
-			MaterialMeshBundle {
+			Mesh3d(meshes.add(Sphere::new(0.3))),
-				mesh: meshes.add(Sphere::new(0.3)),
+			MeshMaterial3d(mat.0.clone()),
-				material: mat.0.clone(),
+			Transform::from_translation(cam_transform.translation),
-				transform: Transform::from_translation(cam_transform.translation),
-				..default()
-			},
 			Collider::ball(0.3),
 			RigidBody::Dynamic,
 			Ccd::enabled(),

game/main/src/shader_extensions/chunk_material.rs

@@ -1,9 +1,9 @@
 use bevy::asset::{Asset, Handle};
+use bevy::image::Image;
 use bevy::pbr::{Material, MaterialExtension};
 use bevy::reflect::TypePath;
 use bevy::render::mesh::{MeshVertexAttribute, MeshVertexBufferLayoutRef};
 use bevy::render::render_resource::{AsBindGroup, ShaderRef};
-use bevy::render::texture::Image;
 use world_generation::consts::{ATTRIBUTE_PACKED_VERTEX_DATA, ATTRIBUTE_VERTEX_HEIGHT};
 
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]

game/main/src/ui/build_ui.rs

@@ -0,0 +1,38 @@
+use bevy::{
+	prelude::*,
+	render::{camera::RenderTarget, view::RenderLayers},
+};
+use shared::{states::AssetLoadState, tags::MainCamera};
+pub struct BuildUIPlugin;
+
+impl Plugin for BuildUIPlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(Startup, setup_cameras);
+		app.add_systems(Update, spawn_ui.run_if(in_state(AssetLoadState::LoadComplete)));
+	}
+}
+
+fn setup_cameras(mut commands: Commands) {
+	commands.spawn((Camera2d, IsDefaultUiCamera, UiBoxShadowSamples(6)));
+}
+
+fn spawn_ui(mut commands: Commands) {
+	commands
+		.spawn((Node {
+			width: Val::Percent(100.),
+			height: Val::Percent(100.),
+			justify_content: JustifyContent::Center,
+			align_items: AlignItems::End,
+			..default()
+		},))
+		.insert(PickingBehavior::IGNORE)
+		.with_children(|parent| {
+			parent.spawn((
+				Node {
+					width: Val::Px(500.),
+					..Default::default()
+				},
+				BackgroundColor(LinearRgba::GREEN.into()),
+			));
+		});
+}

game/main/src/ui/game/build_ui.rs

@@ -1,54 +0,0 @@
-use bevy::{prelude::*, render::view::RenderLayers};
-use bevy_lunex::prelude::*;
-use shared::tags::MainCamera;
-
-pub struct BuildUiPlugin;
-
-impl Plugin for BuildUiPlugin {
-	fn build(&self, app: &mut App) {
-		// app.add_plugins(UiDefaultPlugins)
-		// 	.add_plugins(UiDebugPlugin::<MainUi>::new());
-
-		app.add_systems(PostStartup, setup_ui);
-	}
-}
-
-fn setup_ui(mut commands: Commands, assets: Res<AssetServer>) {
-	commands
-		.spawn((
-			Camera2dBundle {
-				transform: Transform::from_xyz(0.0, 0.0, 1000.0),
-				..default()
-			},
-			MainUi,
-		))
-		.insert(RenderLayers::layer(1));
-
-	commands
-		.spawn((
-			UiTreeBundle::<MainUi> {
-				tree: UiTree::new2d("BuildUi"),
-				..default()
-			},
-			Name::new("Build UI"),
-			SourceFromCamera,
-			RenderLayers::layer(1),
-		))
-		.with_children(|ui| {
-			ui.spawn((
-				UiLink::<MainUi>::path("Root"),
-				UiLayout::boundary()
-					.pos1(Ab(20.0))
-					.pos2(Rl(100.0) - Ab(20.0))
-					.pack::<Base>(),
-				RenderLayers::layer(1),
-			));
-
-			ui.spawn((
-				UiLink::<MainUi>::path("Root/Rect"),
-				UiLayout::solid().size((Ab(1920.0), Ab(1080.0))).pack::<Base>(),
-				UiImage2dBundle::from(assets.load("textures/world/test2.png")),
-				RenderLayers::layer(1),
-			));
-		});
-}

game/main/src/ui/game/mod.rs

@@ -1 +0,0 @@
-pub mod build_ui;

game/main/src/ui/mod.rs

@@ -1 +1 @@
-pub mod game;
+pub mod build_ui;

game/main/src/utlis/debug_plugin.rs

@@ -29,7 +29,7 @@ impl Plugin for DebugPlugin {
 				.run_if(in_state(DebugState::Verbose)),
 		);
 
-		app.add_systems(Update, camera_debug.in_set(GameplaySet));
+		// app.add_systems(Update, camera_debug.in_set(GameplaySet));
 		app.add_systems(Update, regenerate_map.run_if(in_state(GeneratorState::Idle)));
 
 		app.insert_resource(Shape(Polyline3d::new([
@@ -68,12 +68,7 @@ fn regenerate_map(
 fn show_tile_heights(map: Res<Map>, mut gizmos: Gizmos, shape: Res<Shape>, tile_under_cursor: Res<TileUnderCursor>) {
 	if let Some(contact) = tile_under_cursor.0 {
 		let height = map.sample_height(&contact.tile);
-		gizmos.primitive_3d(
+		gizmos.primitive_3d(&shape.0, contact.tile.to_world(height + 0.01), Color::WHITE);
-			&shape.0,
-			contact.tile.to_world(height + 0.01),
-			Quat::IDENTITY,
-			Color::WHITE,
-		);
 
 		gizmos.line(contact.point, contact.point + Vec3::X, LinearRgba::RED);
 		gizmos.line(contact.point, contact.point + Vec3::Y, LinearRgba::GREEN);
@@ -95,11 +90,11 @@ fn show_water_corners(pos: Vec3, gizmos: &mut Gizmos) {
 fn camera_debug(mut cam_query: Query<(&PhosCamera, &PhosOrbitCamera)>, mut gizmos: Gizmos) {
 	let (config, orbit) = cam_query.single();
 
-	gizmos.sphere(orbit.target, Quat::IDENTITY, 0.3, LinearRgba::RED);
+	gizmos.sphere(orbit.target, 0.3, LinearRgba::RED);
 	let cam_proxy = orbit.target - (orbit.forward * 10.0);
 	gizmos.ray(orbit.target, orbit.forward * 10.0, LinearRgba::rgb(1.0, 0.0, 1.0));
 
-	gizmos.circle(cam_proxy, Dir3::Y, 0.3, LinearRgba::rgb(1.0, 1.0, 0.0));
+	gizmos.circle(cam_proxy, 0.3, LinearRgba::rgb(1.0, 1.0, 0.0));
 }
 
 fn verbose_data() {}

game/main/src/utlis/editor_plugin.rs

@@ -14,11 +14,11 @@ impl Plugin for EditorPlugin {
 	fn build(&self, app: &mut App) {
 		app.init_resource::<UIState>();
 
-		app.add_systems(PostUpdate, prepare_image.run_if(in_state(GeneratorState::SpawnMap)));
+		// app.add_systems(PostUpdate, prepare_image.run_if(in_state(GeneratorState::SpawnMap)));
-		app.add_systems(
+		// app.add_systems(
-			Update,
+		// 	Update,
-			(render_map_ui, update_map_render, asset_reloaded).run_if(in_state(GeneratorState::Idle)),
+		// 	(render_map_ui, update_map_render, asset_reloaded).run_if(in_state(GeneratorState::Idle)),
-		);
+		// );
 	}
 }
 
@@ -69,7 +69,7 @@ fn asset_reloaded(
 	let mut rebuild = false;
 	for event in asset_events.read() {
 		match event {
-			AssetEvent::Modified {..}=>	rebuild = true,
+			AssetEvent::Modified { .. } => rebuild = true,
 			_ => (),
 		}
 	}

game/main/src/utlis/tile_selection_plugin.rs

@@ -1,5 +1,8 @@
 use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_rapier3d::{plugin::RapierContext, prelude::QueryFilter};
+use bevy_rapier3d::{
+	plugin::{RapierContext, ReadDefaultRapierContext},
+	prelude::QueryFilter,
+};
 use shared::{
 	resources::{TileContact, TileUnderCursor},
 	tags::MainCamera,
@@ -20,7 +23,7 @@ impl Plugin for TileSelectionPlugin {
 fn update_tile_under_cursor(
 	cam_query: Query<(&GlobalTransform, &Camera), With<MainCamera>>,
 	window: Query<&Window, With<PrimaryWindow>>,
-	rapier_context: Res<RapierContext>,
+	rapier_context: ReadDefaultRapierContext,
 	map: Res<Map>,
 	mut tile_under_cursor: ResMut<TileUnderCursor>,
 ) {
@@ -35,7 +38,7 @@ fn update_tile_under_cursor(
 		return;
 	};
 
-	let Some(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos) else {
+	let Ok(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos) else {
 		return;
 	};
 

game/resources/Cargo.toml

@@ -4,14 +4,14 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.14.2"
+bevy = "0.15.1"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
 serde = { version = "1.0.204", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
 serde_json = "1.0.120"
 ron = "0.8.1"
-bevy_asset_loader = { version = "0.21.0", features = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

game/shared/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.14.2"
+bevy = "0.15.1"
 serde = { version = "1.0.204", features = ["derive"] }
 world_generation = { path = "../../engine/world_generation" }
 

game/shared/src/animation_plugin.rs

@@ -0,0 +1,18 @@
+use bevy::prelude::*;
+
+use crate::prefab_defination::RotationAnimation;
+
+pub struct SimpleAnimationPlugin;
+
+impl Plugin for SimpleAnimationPlugin {
+	fn build(&self, app: &mut App) {
+		app.add_systems(Update, rotate);
+	}
+}
+
+fn rotate(mut query: Query<(&mut Transform, &RotationAnimation)>, time: Res<Time>) {
+	for (mut transform, rot) in query.iter_mut() {
+		let cur_rot = transform.rotation;
+		transform.rotation = cur_rot * Quat::from_axis_angle(rot.axis, rot.speed.to_radians() * time.delta_secs());
+	}
+}

game/shared/src/component_defination.rs

@@ -0,0 +1,20 @@
+use bevy::{
+	ecs::system::EntityCommands, math::{Quat, Vec3}, prelude::*
+};
+use serde::{Deserialize, Serialize};
+
+use crate::prefab_defination::AnimationComponent;
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ComponentDefination {
+	pub path: String,
+	pub animations: Vec<AnimationComponent>,
+}
+
+
+impl ComponentDefination {
+	pub fn apply(&self, commands: &mut EntityCommands){
+		for c in &self.animations {
+			c.apply(commands);
+		}
+	}
+}

game/shared/src/despawn.rs

@@ -24,7 +24,7 @@ impl Plugin for DespawnPuglin {
 
 fn despawn_at(mut commands: Commands, time: Res<Time>, entities: Query<(Entity, &DespawnAt), Without<DespawnAfter>>) {
 	for (entity, at) in entities.iter() {
-		let d = at.0 - time.elapsed_seconds();
+		let d = at.0 - time.elapsed_secs();
 		commands
 			.entity(entity)
 			.insert(DespawnAfter(Timer::from_seconds(d, TimerMode::Once)));

game/shared/src/lib.rs

@@ -9,6 +9,9 @@ pub mod resources;
 pub mod sets;
 pub mod states;
 pub mod tags;
+pub mod prefab_defination;
+pub mod component_defination;
+pub mod animation_plugin;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum Tier {

game/shared/src/prefab_defination.rs

@@ -0,0 +1,79 @@
+use bevy::{
+	ecs::system::{EntityCommand, EntityCommands},
+	gltf::{Gltf, GltfMesh},
+	math::{Quat, Vec3},
+	prelude::*,
+};
+use serde::{Deserialize, Serialize};
+#[derive(Serialize, Deserialize, Debug)]
+pub struct PrefabDefination {
+	pub path: String,
+	pub pos: Vec3,
+	pub rot: Vec3,
+	pub children: Option<Vec<PrefabDefination>>,
+	pub animations: Option<Vec<AnimationComponent>>,
+}
+
+impl PrefabDefination {
+	pub fn spawn_recursive(&self, gltf: &Gltf, commands: &mut ChildBuilder, meshes: &Assets<GltfMesh>) {
+		let mesh_handle = &gltf.named_meshes[&self.path.clone().into_boxed_str()];
+		if let Some(gltf_mesh) = meshes.get(mesh_handle.id()) {
+			let (m, mat) = gltf_mesh.unpack();
+			let mut entity = commands.spawn((
+				Mesh3d(m),
+				MeshMaterial3d(mat),
+				Transform::from_translation(self.pos).with_rotation(Quat::from_euler(
+					bevy::math::EulerRot::XYZ,
+					self.rot.x,
+					self.rot.y,
+					self.rot.z,
+				)),
+			));
+			if let Some(children) = &self.children {
+				entity.with_children(|b| {
+					for child in children {
+						child.spawn_recursive(gltf, b, meshes);
+					}
+				});
+			}
+		}
+	}
+}
+
+pub trait UnpackGltfMesh {
+	fn unpack(&self) -> (Handle<Mesh>, Handle<StandardMaterial>);
+}
+
+impl UnpackGltfMesh for GltfMesh {
+	fn unpack(&self) -> (Handle<Mesh>, Handle<StandardMaterial>) {
+		let p = &self.primitives[0];
+		let mut mat: Handle<StandardMaterial> = default();
+		if let Some(mesh_material) = &p.material {
+			mat = mesh_material.clone();
+		}
+		return (p.mesh.clone(), mat);
+	}
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub enum AnimationComponent {
+	Rotation(RotationAnimation),
+	Slider,
+}
+
+#[derive(Serialize, Deserialize, Debug, Component, Clone, Copy)]
+pub struct RotationAnimation {
+	pub axis: Vec3,
+	pub speed: f32,
+}
+
+impl AnimationComponent {
+	pub fn apply(&self, commands: &mut EntityCommands) {
+		match self {
+			AnimationComponent::Rotation(comp) => {
+				commands.insert(comp.clone());
+			}
+			AnimationComponent::Slider => todo!(),
+		};
+	}
+}

game/units/Cargo.toml

@@ -4,15 +4,15 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.14.2"
+bevy = "0.15.1"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
-bevy_rapier3d = "0.27.0"
+bevy_rapier3d = "0.28.0"
 serde = { version = "1.0.204", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
 serde_json = "1.0.120"
 ron = "0.8.1"
-bevy_asset_loader = { version = "0.21.0", features = [
+bevy_asset_loader = { version = "0.22.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

game/units/src/units_debug_plugin.rs

@@ -34,11 +34,7 @@ fn spawn_test_unit(
 	if let Some(contact) = tile_under_cursor.0 {
 		info!("Spawning Test Unit");
 		commands.spawn((
-			PbrBundle {
+			(Transform::from_translation(contact.surface), Mesh3d(unit.0.clone())),
-				transform: Transform::from_translation(contact.surface),
-				mesh: unit.0.clone(),
-				..default()
-			},
 			Unit,
 			LandUnit,
 		));

game/units/src/units_plugin.rs

@@ -71,7 +71,7 @@ fn move_unit(
 			path.1 += 1;
 			continue;
 		}
-		let vel = d.normalize() * 10.0 * time.delta_seconds();
+		let vel = d.normalize() * 10.0 * time.delta_secs();
 		t.translation += vel;
 		let coord = HexCoord::from_world_pos(t.translation);
 		if map.is_in_bounds(&coord) {