packed testing

engine/world_generation/src/consts.rs

@@ -41,9 +41,9 @@ pub const HEX_NORMALS: [Vec3; 6] = [
 ];
 
 pub const ATTRIBUTE_PACKED_VERTEX_DATA: MeshVertexAttribute =
-	MeshVertexAttribute::new("PackedVertexData", 988540817, VertexFormat::Uint32);
+	MeshVertexAttribute::new("PackedVertexData", 7, VertexFormat::Uint32);
 pub const ATTRIBUTE_VERTEX_HEIGHT: MeshVertexAttribute =
-	MeshVertexAttribute::new("VertexHeight", 988540717, VertexFormat::Float32);
+	MeshVertexAttribute::new("VertexHeight", 8, VertexFormat::Float32);
 
 pub const ATTRIBUTE_TEXTURE_INDEX: MeshVertexAttribute =
 	MeshVertexAttribute::new("TextureIndex", 988540917, VertexFormat::Uint32);

engine/world_generation/src/generators/packed_mesh_generator.rs

@@ -1,9 +1,5 @@
-use crate::hex_utils::HexCoord;
-use crate::map::biome_map::BiomeChunk;
+use crate::hex_utils::{offset3d_to_world, HexCoord};
 use crate::prelude::*;
-use crate::tile_manager::TileAsset;
-use crate::tile_mapper::TileMapperAsset;
-use crate::{biome_asset::BiomeAsset, biome_painter::BiomePainterAsset};
 use bevy::{
 	prelude::*,
 	render::{
@@ -12,32 +8,18 @@ use bevy::{
 	},
 };
 
-pub fn generate_packed_chunk_mesh(
-	chunk: &Chunk,
-	map: &Map,
-	biome_chunk: &BiomeChunk,
-	painter: &BiomePainterAsset,
-	tiles: &Res<Assets<TileAsset>>,
-	biomes: &Res<Assets<BiomeAsset>>,
-	mappers: &Res<Assets<TileMapperAsset>>,
-) -> Mesh {
+pub fn generate_packed_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
 	let vertex_count: usize = Chunk::SIZE * Chunk::SIZE * 6;
 	let mut packed_data = Vec::with_capacity(vertex_count);
 	let mut indices = Vec::with_capacity(vertex_count);
 	let mut heights = Vec::with_capacity(vertex_count);
 
 	for z in 0..Chunk::SIZE {
 		for x in 0..Chunk::SIZE {
-			let height = chunk.heights[x + z * Chunk::SIZE];
-			let data = biome_chunk.data[x + z * Chunk::SIZE];
-			let coord =
-				HexCoord::from_offset(IVec2::new(x as i32, z as i32) + (chunk.chunk_offset * Chunk::SIZE as i32));
-			let n = map.get_neighbors(&coord);
-			let biome = biomes.get(painter.sample_biome(biomes, &data)).unwrap();
-
-			let mapper = mappers.get(biome.tile_mapper.id());
-			let tile_handle = mapper.unwrap().sample_tile(height);
-			let tile = tiles.get(tile_handle).unwrap();
+			let idx = x + z * Chunk::SIZE;
+			let height = chunk.heights[idx];
+			let coord = HexCoord::from_grid_pos(x, z);
+			let n = chunk.get_neighbors(&coord);
 
 			create_packed_tile(
 				UVec2::new(x as u32, z as u32),
@@ -46,8 +28,8 @@ pub fn generate_packed_chunk_mesh(
 				&mut packed_data,
 				&mut indices,
 				&mut heights,
-				tile.texture_id,
-				tile.side_texture_id,
+				chunk.textures[idx][0],
+				chunk.textures[idx][1],
 			);
 		}
 	}
@@ -65,7 +47,7 @@ pub fn generate_packed_chunk_mesh(
 fn create_packed_tile(
 	offset: UVec2,
 	height: f32,
-	neighbors: &[Option<f32>; 6],
+	neighbors: &[f32; 6],
 	packed_data: &mut Vec<u32>,
 	indices: &mut Vec<u32>,
 	heights: &mut Vec<f32>,
@@ -85,23 +67,18 @@ fn create_packed_tile(
 	}
 
 	for i in 0..neighbors.len() {
-		let cur_n = neighbors[i];
-		match cur_n {
-			Some(n_height) => {
-				if n_height < height {
-					create_packed_tile_wall(
-						offset,
-						height,
-						n_height,
-						i,
-						packed_data,
-						indices,
-						heights,
-						side_texture_index,
-					);
-				}
-			}
-			_ => {}
+		let n_height = neighbors[i];
+		if n_height < height {
+			create_packed_tile_wall(
+				offset,
+				height,
+				n_height,
+				i,
+				packed_data,
+				indices,
+				heights,
+				side_texture_index,
+			);
 		}
 	}
 }

game/main/src/map_rendering/map_init.rs

@@ -3,6 +3,7 @@ use bevy::log::*;
 use bevy::{
 	pbr::{ExtendedMaterial, NotShadowCaster},
 	prelude::*,
+	render::render_resource::{ColorTargetState, FragmentState, RenderPipelineDescriptor},
 };
 use bevy_asset_loader::prelude::*;
 
@@ -49,7 +50,7 @@ impl Plugin for MapInitPlugin {
 		app.add_plugins((
 			ChunkRebuildPlugin,
 			// TerraFormingTestPlugin,
-			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
+			MaterialPlugin::<ChunkMaterial>::default(),
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
 				prepass_enabled: false,
 				..Default::default()
@@ -122,19 +123,16 @@ fn finalize_biome_painter(
 fn finalize_texture(
 	mut atlas: ResMut<PhosAssets>,
 	mut images: ResMut<Assets<Image>>,
-	mut chunk_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, ChunkMaterial>>>,
+	mut chunk_materials: ResMut<Assets<ChunkMaterial>>,
 	mut next_load_state: ResMut<NextState<AssetLoadState>>,
 ) {
 	let image = images.get_mut(atlas.handle.id()).unwrap();
 
 	let array_layers = image.height() / image.width();
 	image.reinterpret_stacked_2d_as_array(array_layers);
 
-	let chunk_material = chunk_materials.add(ExtendedMaterial {
-		base: StandardMaterial::default(),
-		extension: ChunkMaterial {
-			array_texture: atlas.handle.clone(),
-		},
+	let chunk_material = chunk_materials.add(ChunkMaterial {
+		array_texture: atlas.handle.clone(),
 	});
 	atlas.chunk_material_handle = chunk_material;
 
@@ -219,6 +217,7 @@ fn spawn_map(
 ) {
 	paint_map(&mut heightmap, &biome_painter, &tile_assets, &tile_mappers);
 
+	//Prepare Mesh Data
 	let map_size = UVec2::new(heightmap.width as u32, heightmap.height as u32);
 	let chunk_meshes: Vec<_> = heightmap
 		.chunks
@@ -236,6 +235,8 @@ fn spawn_map(
 		.collect();
 
 	let mut registry = PhosChunkRegistry::new(chunk_meshes.len());
+
+	//Spawn Chunks
 	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Spawn Chunks").entered();
@@ -277,20 +278,6 @@ fn spawn_map(
 		}
 	}
 
-	// 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);
 	if cur_game_state.get() != &MenuState::InGame {

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<ExtendedMaterial<StandardMaterial, ChunkMaterial>>,
+	pub chunk_material_handle: Handle<ChunkMaterial>,
 	pub water_material: Handle<ExtendedMaterial<StandardMaterial, WaterMaterial>>,
 }
 

game/main/src/shader_extensions/chunk_material.rs

@@ -1,8 +1,11 @@
 use bevy::asset::{Asset, Handle};
-use bevy::pbr::MaterialExtension;
+use bevy::pbr::{Material, MaterialExtension, OpaqueRendererMethod};
+use bevy::prelude::Mesh;
 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)]
 pub struct ChunkMaterial {
@@ -11,25 +14,53 @@ pub struct ChunkMaterial {
 	pub array_texture: Handle<Image>,
 }
 
-impl MaterialExtension for ChunkMaterial {
+impl Material for ChunkMaterial {
 	fn fragment_shader() -> ShaderRef {
-		"shaders/world/chunk.wgsl".into()
+		"shaders/world/chunk_packed.wgsl".into()
 	}
 
-	// fn vertex_shader() -> ShaderRef {
-	// 	"shaders/world/chunk_packed.wgsl".into()
-	// }
+	fn vertex_shader() -> ShaderRef {
+		"shaders/world/chunk_packed.wgsl".into()
+	}
+
+	fn prepass_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 specialize(
+		_pipeline: &bevy::pbr::MaterialPipeline<Self>,
+		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(())
+	}
 
 	// fn specialize(
-	// 	_pipeline: &bevy::pbr::MaterialExtensionPipeline,
 	// 	descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
-	// 	layout: &bevy::render::mesh::MeshVertexBufferLayout,
-	// 	_key: bevy::pbr::MaterialExtensionKey<Self>,
+	// 	layout: &MeshVertexBufferLayoutRef,
+	// 	_key: bevy::pbr::MaterialPipelineKey<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),
+	// 	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),
 	// 	])?;

game/main/src/utlis/chunk_utils.rs

@@ -13,6 +13,7 @@ use world_generation::{
 	generators::{
 		chunk_colliders::generate_chunk_collider,
 		mesh_generator::{generate_chunk_mesh, generate_chunk_water_mesh},
+		packed_mesh_generator::generate_packed_chunk_mesh,
 	},
 	hex_utils::offset_to_world,
 	prelude::{Chunk, Map, MeshChunkData},
@@ -60,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_chunk_mesh(chunk);
+	let chunk_mesh = generate_packed_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);