Vertex data packing

assets/shaders/my_material.wgsl

@@ -0,0 +1,52 @@
+#define_import_path bevy_pbr::my_material
+
+#import bevy_pbr::mesh_view_bindings
+#import bevy_pbr::mesh_bindings
+#import bevy_pbr::forward_io::VertexOutput
+#import bevy_render::maths::affine3_to_square
+
+struct MyExtensionMaterial {
+    quantize_steps: u32,
+};
+
+@group(2) @binding(100)
+var<uniform> my_extension: MyExtensionMaterial;
+
+fn quantize_position(position: vec3<f32>, steps: u32) -> vec3<f32> {
+    if (steps > 0u) {
+        let step_size = 1.0 / f32(steps);
+        return floor(position / step_size) * step_size;
+    }
+    return position;
+}
+
+@vertex
+fn vertex(
+    @location(0) position: vec3<f32>,
+    @location(1) normal: vec3<f32>,
+    @location(2) uv: vec2<f32>,
+    @builtin(instance_index) instance_index: u32,
+) -> VertexOutput {
+    var out: VertexOutput;
+
+    let model_affine = mesh_bindings::mesh[instance_index].world_from_local;
+    let model = affine3_to_square(model_affine);
+
+    let world_position = model * vec4<f32>(position, 1.0);
+
+    var quantized_position = world_position;
+    let quantized_xyz = quantize_position(world_position.xyz, my_extension.quantize_steps);
+    quantized_position.x = quantized_xyz.x;
+    quantized_position.y = quantized_xyz.y;
+    quantized_position.z = quantized_xyz.z;
+
+    out.position = mesh_view_bindings::view.clip_from_world * quantized_position;
+
+    out.world_position = world_position;
+
+    out.world_normal = (model * vec4<f32>(normal, 0.0)).xyz; 
+
+    out.uv = uv;
+
+    return out;
+}

src/client/main.rs

@@ -54,7 +54,7 @@ fn main() {
         wireframe_config::wireframe_plugin(),
         FrameTimeDiagnosticsPlugin,
         EntityCountDiagnosticsPlugin,
-        SystemInformationDiagnosticsPlugin,
+        // SystemInformationDiagnosticsPlugin,
         PerfUiPlugin,
         gui::GuiPlugin,
         networking::NetworkingPlugin,

src/client/networking/systems.rs

@@ -70,12 +70,12 @@ pub fn receive_message_system(
             debug!("Received message: {:?}", message);
             match message {
                 NetworkingMessage::ChunkBatchResponse(chunks) => {
-                    info!("Client received chunk batch response message.");
+                    // info!("Client received chunk batch response message.");
                     for chunk in chunks {
-                        info!(
-                            "Client received chunk response message for: {:?}",
-                            chunk.position
-                        );
+                        // info!(
+                        //     "Client received chunk response message for: {:?}",
+                        //     chunk.position
+                        // );
                         let chunk_position = chunk.position;
                         chunk_manager.insert_chunk(chunk);
                         chunk_mesh_events.send(terrain_events::ChunkMeshUpdateEvent {
@@ -97,7 +97,7 @@ pub fn receive_message_system(
                         .send(remote_player_events::RemotePlayerSyncEvent { players: event });
                 }
                 NetworkingMessage::ServerAsksClientNicelyToRerequestChunkBatch() => {
-                    info!("Client asked for chunk batch.");
+                    // info!("Client asked for chunk batch.");
                     world_regenerate_events.send(terrain_events::WorldRegenerateEvent);
                 }
                 _ => {

src/client/terrain/materials.rs

@@ -0,0 +1,38 @@
+use crate::prelude::*;
+use bevy::{
+    color::palettes::css::RED,
+    pbr::MaterialExtension,
+    reflect::Reflect,
+    render::render_resource::{AsBindGroup, ShaderRef},
+};
+
+const SHADER_ASSET_PATH: &str = "shaders/my_material.wgsl";
+
+#[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
+pub struct MyExtension {
+    #[uniform(100)]
+    pub quantize_steps: u32,
+}
+
+impl MaterialExtension for MyExtension {
+    fn vertex_shader() -> ShaderRef {
+        SHADER_ASSET_PATH.into()
+    }
+}
+
+pub fn create_base_material(
+    texture_handle: Handle<Image>,
+) -> ExtendedMaterial<StandardMaterial, MyExtension> {
+    ExtendedMaterial {
+        base: StandardMaterial {
+            opaque_render_method: OpaqueRendererMethod::Auto,
+            perceptual_roughness: 0.5,
+            reflectance: 0.0,
+            unlit: false,
+            specular_transmission: 0.0,
+            base_color_texture: Some(texture_handle),
+            ..default()
+        },
+        extension: MyExtension { quantize_steps: 12 },
+    }
+}

src/client/terrain/mod.rs

@@ -1,7 +1,10 @@
+use materials::MyExtension;
+
 use crate::prelude::*;
 
 pub mod components;
 pub mod events;
+pub mod materials;
 pub mod resources;
 pub mod systems;
 pub mod util;
@@ -15,6 +18,13 @@ impl Plugin for TerrainPlugin {
         app.insert_resource(util::TextureManager::new());
         app.insert_resource(resources::RenderMaterials::new());
         app.insert_resource(resources::MesherTasks::default());
+        app.insert_resource(resources::MesherTasks::default());
+
+        // Register our custom material extension
+        app.add_plugins(MaterialPlugin::<
+            ExtendedMaterial<StandardMaterial, MyExtension>,
+        >::default());
+
         app.add_event::<terrain_events::BlockUpdateEvent>();
         app.add_event::<terrain_events::ChunkMeshUpdateEvent>();
         app.add_event::<terrain_events::WorldRegenerateEvent>();

src/client/terrain/resources.rs

@@ -2,6 +2,8 @@ use bevy::tasks::Task;
 
 use crate::prelude::*;
 
+use super::materials::MyExtension;
+
 #[derive(Resource)]
 pub struct SpawnAreaLoaded(pub bool);
 
@@ -35,8 +37,8 @@ pub struct MesherTasks {
 
 #[derive(Resource)]
 pub struct RenderMaterials {
-    pub transparent_material: Option<Handle<StandardMaterial>>,
-    pub chunk_material: Option<Handle<StandardMaterial>>,
+    pub transparent_material: Option<Handle<ExtendedMaterial<StandardMaterial, MyExtension>>>,
+    pub chunk_material: Option<Handle<ExtendedMaterial<StandardMaterial, MyExtension>>>,
 }
 
 impl Default for RenderMaterials {

src/client/terrain/systems.rs

@@ -6,17 +6,19 @@ use terrain_resources::{
 
 use crate::prelude::*;
 
+use super::materials::{create_base_material, MyExtension};
+
 pub fn prepare_mesher_materials_system(
     mut render_materials: ResMut<RenderMaterials>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, MyExtension>>>,
     asset_server: Res<AssetServer>,
 ) {
     let texture_handle = obtain_texture_handle(&asset_server);
 
     let material = create_transparent_material(texture_handle.clone());
     render_materials.transparent_material = Some(materials.add(material));
 
-    let material = create_chunk_material(texture_handle);
+    let material = create_base_material(texture_handle);
     render_materials.chunk_material = Some(materials.add(material));
 }
 
@@ -62,12 +64,12 @@ pub fn generate_world_system(
 
     batched_positions.enumerate().for_each(|(index, batch)| {
         let request_positions = batch.to_vec();
-        info!(
-            "Sending chunk batch request for {:?}",
-            request_positions.len()
-        );
+        // info!(
+        //     "Sending chunk batch request for {:?}",
+        //     request_positions.len()
+        // );
         let message = bincode::serialize(&NetworkingMessage::ChunkBatchRequest(request_positions));
-        info!("requesting chunks #{}", index);
+        // info!("requesting chunks #{}", index);
         client.send_message(DefaultChannel::ReliableUnordered, message.unwrap());
     });
 }
@@ -79,10 +81,10 @@ pub fn handle_chunk_mesh_update_events_system(
     mut tasks: ResMut<MesherTasks>,
 ) {
     for event in chunk_mesh_update_events.read() {
-        info!(
-            "Received chunk mesh update event for chunk {:?}",
-            event.position
-        );
+        // info!(
+        //     "Received chunk mesh update event for chunk {:?}",
+        //     event.position
+        // );
         let chunk_option = chunk_manager.get_chunk(event.position);
         match chunk_option {
             Some(chunk) => {
@@ -171,12 +173,12 @@ fn create_chunk_bundle(
     mesh_handle: Handle<Mesh>,
     chunk_position: Vec3,
     mesh_type: MeshType,
-    material_handle: Handle<StandardMaterial>,
+    material_handle: Handle<ExtendedMaterial<StandardMaterial, MyExtension>>,
 ) -> (
     bevy::prelude::Mesh3d,
     bevy::prelude::Transform,
     ChunkMesh,
-    bevy::prelude::MeshMaterial3d<StandardMaterial>,
+    bevy::prelude::MeshMaterial3d<ExtendedMaterial<StandardMaterial, MyExtension>>,
 ) {
     (
         Mesh3d(mesh_handle),
@@ -197,17 +199,22 @@ fn create_chunk_bundle(
     )
 }
 
-fn create_transparent_material(texture_handle: Handle<Image>) -> StandardMaterial {
-    StandardMaterial {
-        perceptual_roughness: 1.0,
-        double_sided: true,
-        cull_mode: None,
-        reflectance: 0.0,
-        unlit: false,
-        specular_transmission: 0.0,
-        alpha_mode: AlphaMode::Mask(1.0),
-        base_color_texture: Some(texture_handle),
-        ..default()
+fn create_transparent_material(
+    texture_handle: Handle<Image>,
+) -> ExtendedMaterial<StandardMaterial, MyExtension> {
+    ExtendedMaterial {
+        base: StandardMaterial {
+            perceptual_roughness: 1.0,
+            double_sided: true,
+            cull_mode: None,
+            reflectance: 0.0,
+            unlit: false,
+            specular_transmission: 0.0,
+            alpha_mode: AlphaMode::Mask(1.0),
+            base_color_texture: Some(texture_handle),
+            ..default()
+        },
+        extension: MyExtension { quantize_steps: 12 },
     }
 }
 
@@ -242,7 +249,7 @@ pub fn handle_terrain_regeneration_events_system(
     chunk_manager: ResMut<ChunkManager>,
 ) {
     for _ in world_regenerate_events.read() {
-        info!("Rerequesting all chunks from server");
+        // info!("Rerequesting all chunks from server");
         let all_chunk_positions = chunk_manager.get_all_chunk_positions();
         let message =
             bincode::serialize(&NetworkingMessage::ChunkBatchRequest(all_chunk_positions));