water shader

engine/world_generation/src/map/map.rs

@@ -95,7 +95,7 @@ impl Map {
 			let d = (r as f32) / (radius as f32);
 			let cur = *h;
 			let h2 = cur - depth;
-			*h = h2.lerp(cur, d * d);
+			*h = h2.lerp(cur, d * d).max(0.);
 
 			return p.to_chunk_index(width);
 		});

game/main/src/camera_system/camera_plugin.rs

@@ -1,4 +1,5 @@
 use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin};
+use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::input::mouse::{MouseMotion, MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
 use bevy::window::CursorGrabMode;
@@ -35,6 +36,7 @@ fn setup(mut commands: Commands, mut msaa: ResMut<Msaa>) {
 			},
 			PhosCamera::default(),
 			MainCamera,
+			DepthPrepass,
 			PhosCameraTargets::default(),
 		))
 		.insert(TemporalAntiAliasBundle::default());

game/main/src/main.rs

@@ -3,6 +3,7 @@ use bevy::prelude::*;
 use bevy::render::texture::{ImageAddressMode, ImageFilterMode, ImageSamplerDescriptor};
 use bevy::window::PresentMode;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
+use bevy_inspector_egui::DefaultInspectorConfigPlugin;
 use phos::PhosGamePlugin;
 
 mod camera_system;

game/main/src/map_rendering/map_init.rs

@@ -1,6 +1,12 @@
+use std::sync::Arc;
+
 #[cfg(feature = "tracing")]
 use bevy::log::*;
-use bevy::{asset::LoadState, pbr::ExtendedMaterial, prelude::*};
+use bevy::{
+	asset::{LoadState, StrongHandle},
+	pbr::{ExtendedMaterial, NotShadowCaster},
+	prelude::*,
+};
 use bevy_inspector_egui::quick::ResourceInspectorPlugin;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use shared::states::{GameState, GameplayState};
@@ -16,7 +22,10 @@ use world_generation::{
 use crate::{
 	camera_system::components::*,
 	prelude::{ChunkAtlas, PhosChunk, PhosChunkRegistry},
-	shader_extensions::chunk_material::ChunkMaterial,
+	shader_extensions::{
+		chunk_material::ChunkMaterial,
+		water_material::{WaterMaterial, WaterSettings},
+	},
 	utlis::{
 		chunk_utils::{paint_map, prepare_chunk_mesh_with_collider},
 		render_distance_system::RenderDistanceVisibility,
@@ -34,10 +43,18 @@ impl Plugin for MapInitPlugin {
 		app.insert_state(GeneratorState::GenerateHeightmap);
 		app.insert_state(AssetLoadState::StartLoading);
 
+		app.add_plugins(ResourceInspectorPlugin::<GenerationConfig>::default());
+		app.add_plugins(ResourceInspectorPlugin::<WaterInspect>::default());
+		app.register_type::<ExtendedMaterial<StandardMaterial, WaterMaterial>>();
+		app.register_asset_reflect::<ExtendedMaterial<StandardMaterial, WaterMaterial>>();
 		app.add_plugins((
-			ResourceInspectorPlugin::<GenerationConfig>::default(),
 			ChunkRebuildPlugin,
 			TerraFormingTestPlugin,
+			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
+			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
+				prepass_enabled: false,
+				..Default::default()
+			},
 		));
 
 		app.add_systems(Startup, (load_textures, load_tiles).in_set(AssetLoaderSet));
@@ -71,18 +88,33 @@ struct GeneratorSet;
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 struct AssetLoaderSet;
 
+#[derive(Resource, Reflect, Default)]
+#[reflect(Resource)]
+struct WaterInspect(Handle<ExtendedMaterial<StandardMaterial, WaterMaterial>>);
+
 fn load_textures(
 	mut commands: Commands,
 	asset_server: Res<AssetServer>,
-	mut standard_materials: ResMut<Assets<StandardMaterial>>,
+	mut water_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, WaterMaterial>>>,
 ) {
 	let main_tex = asset_server.load("textures/world/stack.png");
 
-	let water_material = standard_materials.add(StandardMaterial {
-		base_color: Color::AQUAMARINE.with_a(0.5),
-		alpha_mode: AlphaMode::Blend,
-		..default()
+	let water_material = water_materials.add(ExtendedMaterial {
+		base: StandardMaterial {
+			base_color: Color::CYAN.with_a(1.),
+			alpha_mode: AlphaMode::Blend,
+			..Default::default()
+		},
+		extension: WaterMaterial {
+			settings: WaterSettings {
+				offset: 0.5,
+				scale: 100.,
+				..Default::default()
+			},
+			..default()
+		},
 	});
+	commands.insert_resource(WaterInspect(water_material.clone()));
 	commands.insert_resource(ChunkAtlas {
 		handle: main_tex.clone(),
 		is_loaded: false,
@@ -221,7 +253,7 @@ fn create_heightmap(
 		size: UVec2::splat(1024 / Chunk::SIZE as u32),
 		// size: UVec2::splat(1),
 	};
-	let heightmap = generate_heightmap(&config, 4);
+	let heightmap = generate_heightmap(&config, 42069);
 
 	let (mut cam_t, cam_entity) = cam.single_mut();
 	cam_t.translation = heightmap.get_center();
@@ -286,16 +318,19 @@ fn spawn_map(
 		}
 	}
 
-	commands.spawn((PbrBundle {
-		transform: Transform::from_translation(heightmap.get_center()),
-		mesh: meshes.add(
-			Plane3d::default()
-				.mesh()
-				.size(heightmap.get_world_width(), heightmap.get_world_height()),
-		),
-		material: atlas.water_material.clone(),
-		..default()
-	},));
+	commands.spawn((
+		MaterialMeshBundle {
+			transform: Transform::from_translation(heightmap.get_center()),
+			mesh: meshes.add(
+				Plane3d::default()
+					.mesh()
+					.size(heightmap.get_world_width(), heightmap.get_world_height()),
+			),
+			material: atlas.water_material.clone(),
+			..default()
+		},
+		NotShadowCaster,
+	));
 
 	commands.insert_resource(registry);
 	generator_state.set(GeneratorState::Idle);

game/main/src/phos.rs

@@ -27,7 +27,6 @@ impl Plugin for PhosGamePlugin {
 		app.add_plugins((
 			PhosCameraPlugin,
 			MapInitPlugin,
-			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
 			RenderDistancePlugin,
 			BuildingPugin,
 			DespawnPuglin,

game/main/src/prelude.rs

@@ -2,15 +2,15 @@ use bevy::asset::Handle;
 use bevy::pbr::ExtendedMaterial;
 use bevy::prelude::*;
 use bevy::prelude::{Component, Image, Resource};
-use bevy::reflect::Reflect;
 
 use crate::shader_extensions::chunk_material::ChunkMaterial;
+use crate::shader_extensions::water_material::WaterMaterial;
 
-#[derive(Resource)]
+#[derive(Resource, Default)]
 pub struct ChunkAtlas {
 	pub handle: Handle<Image>,
 	pub chunk_material_handle: Handle<ExtendedMaterial<StandardMaterial, ChunkMaterial>>,
-	pub water_material: Handle<StandardMaterial>,
+	pub water_material: Handle<ExtendedMaterial<StandardMaterial, WaterMaterial>>,
 	pub is_loaded: bool,
 }
 

game/main/src/shader_extensions/mod.rs

@@ -1 +1,2 @@
 pub mod chunk_material;
+pub mod water_material;

game/main/src/shader_extensions/water_material.rs

@@ -0,0 +1,51 @@
+use bevy::asset::Asset;
+use bevy::pbr::MaterialExtension;
+use bevy::reflect::Reflect;
+use bevy::render::color::Color;
+use bevy::render::render_resource::{AsBindGroup, ShaderRef, ShaderType};
+
+#[derive(Asset, Reflect, AsBindGroup, Debug, Clone, Default)]
+pub struct WaterMaterial {
+	#[uniform(100)]
+	pub settings: WaterSettings,
+}
+
+#[derive(Debug, Clone, ShaderType, Reflect)]
+pub struct WaterSettings {
+	pub offset: f32,
+	pub scale: f32,
+	pub deep_color: Color,
+}
+
+impl Default for WaterSettings {
+	fn default() -> Self {
+		Self {
+			offset: 0.0,
+			scale: 1.0,
+			deep_color: Color::BLACK,
+		}
+	}
+}
+
+impl MaterialExtension for WaterMaterial {
+	fn fragment_shader() -> ShaderRef {
+		"shaders/world/water.wgsl".into()
+	}
+
+	// fn specialize(
+	// 	_pipeline: &bevy::pbr::MaterialExtensionPipeline,
+	// 	descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
+	// 	layout: &bevy::render::mesh::MeshVertexBufferLayout,
+	// 	_key: bevy::pbr::MaterialExtensionKey<Self>,
+	// ) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
+	// 	let vertex_layout = layout.get_layout(&[
+	// 		// Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
+	// 		// Mesh::ATTRIBUTE_UV_0.at_shader_location(1),
+	// 		// Mesh::ATTRIBUTE_NORMAL.at_shader_location(2),
+	// 		ATTRIBUTE_PACKED_VERTEX_DATA.at_shader_location(7),
+	// 		ATTRIBUTE_VERTEX_HEIGHT.at_shader_location(8),
+	// 	])?;
+	// 	descriptor.vertex.buffers = vec![vertex_layout];
+	// 	Ok(())
+	// }
+}