cleanup

game/main/src/map_rendering/map_init.rs

@@ -50,7 +50,7 @@ impl Plugin for MapInitPlugin {
 		app.add_plugins((
 			ChunkRebuildPlugin,
 			// TerraFormingTestPlugin,
-			MaterialPlugin::<ChunkMaterial>::default(),
+			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
 				prepass_enabled: false,
 				..Default::default()
@@ -123,7 +123,7 @@ fn finalize_biome_painter(
 fn finalize_texture(
 	mut atlas: ResMut<PhosAssets>,
 	mut images: ResMut<Assets<Image>>,
-	mut chunk_materials: ResMut<Assets<ChunkMaterial>>,
+	mut chunk_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, ChunkMaterial>>>,
 	mut next_load_state: ResMut<NextState<AssetLoadState>>,
 ) {
 	let image = images.get_mut(atlas.handle.id()).unwrap();
@@ -131,8 +131,11 @@ fn finalize_texture(
 	let array_layers = image.height() / image.width();
 	image.reinterpret_stacked_2d_as_array(array_layers);
 
-	let chunk_material = chunk_materials.add(ChunkMaterial {
+	let chunk_material = chunk_materials.add(ExtendedMaterial {
+		base: StandardMaterial::default(),
+		extension: ChunkMaterial {
 			array_texture: atlas.handle.clone(),
+		},
 	});
 	atlas.chunk_material_handle = chunk_material;
 

game/main/src/prelude.rs

@@ -12,7 +12,7 @@ use crate::shader_extensions::water_material::WaterMaterial;
 pub struct PhosAssets {
 	#[asset(key = "chunk_atlas")]
 	pub handle: Handle<Image>,
-	pub chunk_material_handle: Handle<ChunkMaterial>,
+	pub chunk_material_handle: Handle<ExtendedMaterial<StandardMaterial, ChunkMaterial>>,
 	pub water_material: Handle<ExtendedMaterial<StandardMaterial, WaterMaterial>>,
 }
 

game/main/src/shader_extensions/chunk_material.rs

@@ -1,6 +1,5 @@
 use bevy::asset::{Asset, Handle};
-use bevy::pbr::{Material, MaterialExtension, OpaqueRendererMethod};
-use bevy::prelude::Mesh;
+use bevy::pbr::{Material, MaterialExtension};
 use bevy::reflect::TypePath;
 use bevy::render::mesh::{MeshVertexAttribute, MeshVertexBufferLayoutRef};
 use bevy::render::render_resource::{AsBindGroup, ShaderRef};
@@ -14,9 +13,22 @@ pub struct ChunkMaterial {
 	pub array_texture: Handle<Image>,
 }
 
-impl Material for ChunkMaterial {
+impl MaterialExtension for ChunkMaterial {
 	fn fragment_shader() -> ShaderRef {
-		"shaders/world/chunk_packed.wgsl".into()
+		"shaders/world/chunk.wgsl".into()
+	}
+}
+
+#[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
+pub struct PackedChunkMaterial {
+	#[texture(100, dimension = "2d_array")]
+	#[sampler(101)]
+	pub array_texture: Handle<Image>,
+}
+
+impl Material for PackedChunkMaterial {
+	fn fragment_shader() -> ShaderRef {
+		"shaders/world/chunk.wgsl".into()
 	}
 
 	fn vertex_shader() -> ShaderRef {
@@ -27,13 +39,13 @@ impl Material for ChunkMaterial {
 		"shaders/world/chunk_packed.wgsl".into()
 	}
 
-	fn deferred_vertex_shader() -> ShaderRef {
-		"shaders/world/chunk_packed.wgsl".into()
-	}
+	// fn deferred_vertex_shader() -> ShaderRef {
+	// 	"shaders/world/chunk_packed.wgsl".into()
+	// }
 
-	fn opaque_render_method(&self) -> bevy::pbr::OpaqueRendererMethod {
-		return OpaqueRendererMethod::Auto;
-	}
+	// fn opaque_render_method(&self) -> bevy::pbr::OpaqueRendererMethod {
+	// 	return OpaqueRendererMethod::Auto;
+	// }
 
 	fn specialize(
 		_pipeline: &bevy::pbr::MaterialPipeline<Self>,
@@ -51,20 +63,4 @@ impl Material for ChunkMaterial {
 		descriptor.vertex.buffers = vec![vertex_layout];
 		Ok(())
 	}
-
-	// fn specialize(
-	// 	descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
-	// 	layout: &MeshVertexBufferLayoutRef,
-	// 	_key: bevy::pbr::MaterialPipelineKey<Self>,
-	// ) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
-	// 	let vertex_layout = layout.0.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(())
-	// }
 }

game/main/src/utlis/chunk_utils.rs

@@ -61,7 +61,7 @@ pub fn prepare_chunk_mesh(
 ) -> (Mesh, Mesh, (Vec<Vec3>, Vec<[u32; 3]>), Vec3, usize) {
 	#[cfg(feature = "tracing")]
 	let _gen_mesh = info_span!("Generate Chunk").entered();
-	let chunk_mesh = generate_packed_chunk_mesh(chunk);
+	let chunk_mesh = generate_chunk_mesh(chunk);
 	let water_mesh = generate_chunk_water_mesh(chunk, sealevel, map_size.x as usize, map_size.y as usize);
 	let col_data = generate_chunk_collider(chunk);