update inspector

added general render distance system

game/camera_system/src/lib.rs

@@ -1,37 +1,28 @@
 use crate::prelude::PhosCamera;
+use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin};
 use bevy::input::mouse::MouseMotion;
 use bevy::pbr::ScreenSpaceAmbientOcclusionBundle;
 use bevy::prelude::*;
 use bevy::window::CursorGrabMode;
 
-pub mod prelude {
-	use bevy::prelude::Component;
-
-	#[derive(Component, Default)]
-	pub struct PhosCamera {
-		pub min_height: f32,
-		pub max_height: f32,
-		pub speed: f32,
-	}
-}
+pub mod prelude;
 
 pub struct PhosCameraPlugin;
 
 impl Plugin for PhosCameraPlugin {
 	fn build(&self, app: &mut App) {
-		app.add_systems(Startup, setup).add_systems(
-			Update,
-			(grab_mouse, (update_camera, update_camera_mouse).chain()),
-		);
+		app.add_systems(Startup, setup)
+			.add_systems(Update, (grab_mouse, (update_camera, update_camera_mouse).chain()));
+
+		app.add_plugins(TemporalAntiAliasPlugin);
 	}
 }
 
-fn setup(mut commands: Commands) {
+fn setup(mut commands: Commands, mut msaa: ResMut<Msaa>) {
 	commands
 		.spawn((
 			Camera3dBundle {
-				transform: Transform::from_xyz(0., 30., 0.)
-					.looking_at(Vec3::new(1000., 0., 1000.), Vec3::Y),
+				transform: Transform::from_xyz(0., 30., 0.).looking_at(Vec3::new(1000., 0., 1000.), Vec3::Y),
 				..default()
 			},
 			PhosCamera {
@@ -39,7 +30,10 @@ fn setup(mut commands: Commands) {
 				..default()
 			},
 		))
-		.insert(ScreenSpaceAmbientOcclusionBundle::default());
+		.insert(ScreenSpaceAmbientOcclusionBundle::default())
+		.insert(TemporalAntiAliasBundle::default());
+
+	*msaa = Msaa::Off;
 }
 fn update_camera(
 	mut cam_query: Query<(&PhosCamera, &mut Transform)>,
@@ -106,16 +100,11 @@ fn update_camera_mouse(
 		pitch = pitch.clamp(-1.54, 1.54);
 
 		// Order is important to prevent unintended roll
-		transform.rotation =
-			Quat::from_axis_angle(Vec3::Y, yaw) * Quat::from_axis_angle(Vec3::X, pitch);
+		transform.rotation = Quat::from_axis_angle(Vec3::Y, yaw) * Quat::from_axis_angle(Vec3::X, pitch);
 	}
 }
 
-fn grab_mouse(
-	mut windows: Query<&mut Window>,
-	mouse: Res<ButtonInput<MouseButton>>,
-	key: Res<ButtonInput<KeyCode>>,
-) {
+fn grab_mouse(mut windows: Query<&mut Window>, mouse: Res<ButtonInput<MouseButton>>, key: Res<ButtonInput<KeyCode>>) {
 	let mut window = windows.single_mut();
 
 	if mouse.just_pressed(MouseButton::Middle) {
@@ -128,3 +117,8 @@ fn grab_mouse(
 		window.cursor.grab_mode = CursorGrabMode::None;
 	}
 }
+
+
+fn rts_camera_system(){
+
+}

game/camera_system/src/prelude.rs

@@ -0,0 +1,14 @@
+use bevy::prelude::*;
+
+#[derive(Component, Default)]
+pub struct PhosCamera {
+	pub min_height: f32,
+	pub max_height: f32,
+	pub speed: f32,
+	pub zoom_speed: f32,
+}
+
+pub struct CameraBounds {
+	pub min: Vec2,
+	pub max: Vec2,
+}

game/main/src/main.rs

@@ -8,6 +8,7 @@ mod map_init;
 mod phos;
 mod prelude;
 mod shader_extensions;
+mod utlis;
 use phos::PhosGamePlugin;
 
 fn main() {

game/main/src/map_init.rs

@@ -1,33 +1,43 @@
 use bevy::{asset::LoadState, pbr::ExtendedMaterial, prelude::*};
+use bevy_inspector_egui::quick::ResourceInspectorPlugin;
 use bevy_rapier3d::geometry::{Collider, TriMeshFlags};
+use camera_system::prelude::PhosCamera;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use world_generation::{
-	biome_painter::*, chunk_colliders::generate_chunk_collider, heightmap::generate_heightmap,
-	hex_utils::offset_to_world, mesh_generator::generate_chunk_mesh, prelude::*, tile_manager::*,
+	biome_painter::*,
+	chunk_colliders::generate_chunk_collider,
+	heightmap::generate_heightmap,
+	hex_utils::{offset_to_world, tile_to_world_distance},
+	mesh_generator::generate_chunk_mesh,
+	prelude::*,
+	tile_manager::*,
 	tile_mapper::*,
 };
 
 use crate::{
 	prelude::{ChunkAtlas, PhosChunk, PhosMap},
 	shader_extensions::chunk_material::ChunkMaterial,
+	utlis::render_distance_system::RenderDistanceVisibility,
 };
 
 pub struct MapInitPlugin;
 
 impl Plugin for MapInitPlugin {
 	fn build(&self, app: &mut App) {
-		app.add_systems(Startup, init_map)
-			.add_systems(Startup, (load_textures, load_tiles, create_map).chain());
+		app.add_plugins((
+			ResourceInspectorPlugin::<PhosMap>::default(),
+			ResourceInspectorPlugin::<GenerationConfig>::default(),
+		));
 
-		app.add_systems(Update, (finalize_texture, spawn_map));
+		app.add_systems(Startup, (load_textures, load_tiles, create_map));
+
+		app.add_systems(Update, finalize_texture);
+		app.add_systems(PostUpdate, (despawn_map, spawn_map).chain());
+		app.insert_resource(TileManager::default());
+		app.insert_resource(PhosMap::default());
 	}
 }
 
-fn init_map(mut commands: Commands) {
-	commands.insert_resource(PhosMap::default());
-	commands.insert_resource(TileManager::default());
-}
-
 fn load_textures(mut commands: Commands, asset_server: Res<AssetServer>) {
 	let main_tex = asset_server.load("textures/world/stack.png");
 	commands.insert_resource(ChunkAtlas {
@@ -77,69 +87,88 @@ fn finalize_texture(
 	map.regenerate = true;
 }
 
-fn create_map(mut commands: Commands) {
-	let heightmap = generate_heightmap(
-		&GenerationConfig {
-			layers: vec![
-				GeneratorLayer {
-					base_roughness: 2.14,
-					roughness: 0.87,
-					strength: 2.93,
-					min_value: -0.2,
-					persistence: 0.77,
-					is_rigid: false,
-					weight: 0.,
-					weight_multi: 0.,
-					layers: 4,
-					first_layer_mask: false,
-				},
-				GeneratorLayer {
-					base_roughness: 2.85,
-					roughness: 2.,
-					strength: -0.23,
-					min_value: -0.,
-					persistence: 1.,
-					is_rigid: false,
-					weight: 0.,
-					weight_multi: 0.,
-					layers: 4,
-					first_layer_mask: false,
-				},
-				GeneratorLayer {
-					base_roughness: 2.6,
-					roughness: 4.,
-					strength: 10.44,
-					min_value: 0.,
-					persistence: 1.57,
-					is_rigid: true,
-					weight: 1.,
-					weight_multi: 0.35,
-					layers: 4,
-					first_layer_mask: true,
-				},
-				GeneratorLayer {
-					base_roughness: 3.87,
-					roughness: 5.8,
-					strength: -1.,
-					min_value: 0.,
-					persistence: 0.,
-					is_rigid: true,
-					weight: 1.,
-					weight_multi: 4.57,
-					layers: 3,
-					first_layer_mask: true,
-				},
-			],
-			noise_scale: 350.,
-			sea_level: 4.,
-			border_size: 64.,
-			size: UVec2::splat(1024 / Chunk::SIZE as u32),
-			// size: UVec2::splat(1),
-		},
-		4,
-	);
+fn create_map(mut commands: Commands, mut cam: Query<&mut Transform, With<PhosCamera>>) {
+	let config = GenerationConfig {
+		layers: vec![
+			GeneratorLayer {
+				base_roughness: 2.14,
+				roughness: 0.87,
+				strength: 2.93,
+				min_value: -0.2,
+				persistence: 0.77,
+				is_rigid: false,
+				weight: 0.,
+				weight_multi: 0.,
+				layers: 4,
+				first_layer_mask: false,
+			},
+			GeneratorLayer {
+				base_roughness: 2.85,
+				roughness: 2.,
+				strength: -0.23,
+				min_value: -0.,
+				persistence: 1.,
+				is_rigid: false,
+				weight: 0.,
+				weight_multi: 0.,
+				layers: 4,
+				first_layer_mask: false,
+			},
+			GeneratorLayer {
+				base_roughness: 2.6,
+				roughness: 4.,
+				strength: 4.3,
+				min_value: 0.,
+				persistence: 1.57,
+				is_rigid: true,
+				weight: 1.,
+				weight_multi: 0.35,
+				layers: 4,
+				first_layer_mask: true,
+			},
+			GeneratorLayer {
+				base_roughness: 3.87,
+				roughness: 5.8,
+				strength: -1.,
+				min_value: 0.,
+				persistence: 0.,
+				is_rigid: true,
+				weight: 1.,
+				weight_multi: 4.57,
+				layers: 3,
+				first_layer_mask: true,
+			},
+			GeneratorLayer {
+				base_roughness: 3.87,
+				roughness: 5.8,
+				strength: -1.5,
+				min_value: 0.,
+				persistence: 0.3,
+				is_rigid: true,
+				weight: 1.,
+				weight_multi: 4.57,
+				layers: 3,
+				first_layer_mask: true,
+			},
+		],
+		noise_scale: 450.,
+		sea_level: 8.5,
+		border_size: 64.,
+		size: UVec2::splat(1024 / Chunk::SIZE as u32),
+		// size: UVec2::splat(1),
+	};
+	let heightmap = generate_heightmap(&config, 4);
 
 	commands.insert_resource(heightmap);
+
+	// let mut cam_t = cam.single_mut();
+	// cam_t.translation = Vec3::new(
+	// 	tile_to_world_distance(config.size.x as i32 / 2),
+	// 	cam_t.translation.y,
+	// 	tile_to_world_distance(config.size.y as i32 / 2),
+	// );
+
+	commands.insert_resource(config);
 }
 
 fn spawn_map(
@@ -172,8 +201,7 @@ fn spawn_map(
 		.chunks
 		.par_iter()
 		.map(|chunk: &Chunk| {
-			let mesh =
-				generate_chunk_mesh(chunk, &heightmap, cur_painter, &tile_assets, &tile_mappers);
+			let mesh = generate_chunk_mesh(chunk, &heightmap, cur_painter, &tile_assets, &tile_mappers);
 			let collision = generate_chunk_collider(chunk, &heightmap);
 			return (
 				mesh,
@@ -192,11 +220,29 @@ fn spawn_map(
 				..default()
 			},
 			PhosChunk,
-			Collider::trimesh_with_flags(
-				col_verts,
-				col_indicies,
-				TriMeshFlags::MERGE_DUPLICATE_VERTICES,
-			),
+			RenderDistanceVisibility::default().with_offset(Vec3::new(
+				tile_to_world_distance(Chunk::SIZE as i32 / 2),
+				0.,
+				tile_to_world_distance(Chunk::SIZE as i32 / 2),
+			)),
+			Collider::trimesh_with_flags(col_verts, col_indicies, TriMeshFlags::MERGE_DUPLICATE_VERTICES),
 		));
 	}
 }
+
+fn despawn_map(
+	mut commands: Commands,
+	mut heightmap: ResMut<Map>,
+	cfg: Res<GenerationConfig>,
+	map: Res<PhosMap>,
+	chunks: Query<Entity, With<PhosChunk>>,
+) {
+	if !map.regenerate {
+		return;
+	}
+	for chunk in chunks.iter() {
+		commands.entity(chunk).despawn();
+	}
+
+	*heightmap = generate_heightmap(&cfg, 4);
+}

game/main/src/phos.rs

@@ -1,6 +1,7 @@
 use crate::map_init::MapInitPlugin;
 use crate::prelude::*;
 use crate::shader_extensions::chunk_material::ChunkMaterial;
+use crate::utlis::render_distance_system::RenderDistancePlugin;
 use bevy::pbr::ExtendedMaterial;
 use bevy::{
 	pbr::{wireframe::WireframeConfig, CascadeShadowConfig},
@@ -9,12 +10,10 @@ use bevy::{
 use bevy_rapier3d::dynamics::{Ccd, RigidBody, Velocity};
 use bevy_rapier3d::geometry::Collider;
 use bevy_rapier3d::plugin::{NoUserData, RapierPhysicsPlugin};
-use bevy_rapier3d::render::RapierDebugRenderPlugin;
 use camera_system::prelude::PhosCamera;
 use camera_system::PhosCameraPlugin;
 use iyes_perf_ui::prelude::*;
 use world_generation::biome_painter::BiomePainterPlugin;
-use world_generation::prelude::*;
 use world_generation::tile_manager::TileAssetPlugin;
 use world_generation::tile_mapper::TileMapperAssetPlugin;
 
@@ -26,13 +25,14 @@ impl Plugin for PhosGamePlugin {
 			PhosCameraPlugin,
 			MapInitPlugin,
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
+			RenderDistancePlugin,
 		));
 
 		//Systems - Startup
 		app.add_systems(Startup, init_game);
 
 		//Systems - Update
-		app.add_systems(Update, (spawn_sphere, render_distance_system));
+		app.add_systems(Update, spawn_sphere);
 
 		//Perf UI
 		app.add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
@@ -111,19 +111,3 @@ fn spawn_sphere(
 		));
 	}
 }
-fn render_distance_system(
-	mut chunks: Query<(&Transform, &mut Visibility), With<PhosChunk>>,
-	camera: Query<&Transform, With<PhosCamera>>,
-) {
-	let cam = camera.single();
-	for (transform, mut visibility) in chunks.iter_mut() {
-		let dist = (transform.translation - cam.translation
-			+ Vec3::new((Chunk::SIZE / 2) as f32, 0., (Chunk::SIZE / 2) as f32))
-		.length();
-		if dist > 500. {
-			*visibility = Visibility::Hidden;
-		} else {
-			*visibility = Visibility::Visible;
-		}
-	}
-}

game/main/src/prelude.rs

@@ -1,5 +1,7 @@
 use bevy::asset::Handle;
+use bevy::prelude::*;
 use bevy::prelude::{Component, Image, Resource};
+use bevy::reflect::Reflect;
 
 #[derive(Resource)]
 pub struct ChunkAtlas {
@@ -7,7 +9,8 @@ pub struct ChunkAtlas {
 	pub is_loaded: bool,
 }
 
-#[derive(Resource, Default)]
+#[derive(Resource, Default, Reflect)]
+#[reflect(Resource)]
 pub struct PhosMap {
 	pub ready: bool,
 	pub regenerate: bool,

game/main/src/utlis/mod.rs

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

game/main/src/utlis/render_distance_system.rs

@@ -0,0 +1,75 @@
+use bevy::prelude::*;
+use camera_system::prelude::PhosCamera;
+
+pub struct RenderDistancePlugin;
+
+impl Plugin for RenderDistancePlugin {
+	fn build(&self, app: &mut bevy::prelude::App) {
+		app.register_type::<RenderDistanceSettings>();
+		app.add_systems(PostUpdate, render_distance_system)
+			.insert_resource(RenderDistanceSettings::default());
+	}
+}
+
+#[derive(Resource, Reflect)]
+#[reflect(Resource)]
+pub struct RenderDistanceSettings {
+	pub render_distance: f32,
+}
+
+impl RenderDistanceSettings {
+	pub fn new(distance: f32) -> Self {
+		return Self {
+			render_distance: distance,
+		};
+	}
+}
+
+impl Default for RenderDistanceSettings {
+	fn default() -> Self {
+		Self::new(500.)
+	}
+}
+
+#[derive(Component)]
+pub struct RenderDistanceVisibility {
+	pub distance_multiplier: f32,
+	pub offset: Vec3,
+}
+
+impl RenderDistanceVisibility {
+	pub fn with_offset(mut self, offset: Vec3) -> Self {
+		self.offset = offset;
+		return self;
+	}
+
+	pub fn with_multiplier(mut self, distance_multiplier: f32) -> Self {
+		self.distance_multiplier = distance_multiplier;
+		return self;
+	}
+}
+
+impl Default for RenderDistanceVisibility {
+	fn default() -> Self {
+		Self {
+			distance_multiplier: 1.,
+			offset: Vec3::ZERO,
+		}
+	}
+}
+
+fn render_distance_system(
+	mut objects: Query<(&Transform, &mut Visibility, &RenderDistanceVisibility)>,
+	camera_query: Query<&Transform, With<PhosCamera>>,
+	settings: Res<RenderDistanceSettings>,
+) {
+	let camera = camera_query.single();
+	for (t, mut vis, r) in objects.iter_mut() {
+		let dist = (camera.translation - (t.translation + r.offset)).length() * r.distance_multiplier;
+		if settings.render_distance < dist {
+			*vis = Visibility::Hidden;
+		} else {
+			*vis = Visibility::Visible;
+		}
+	}
+}