From 2987be4fc5c695d726825d6f3aaa408a2e3bb5bd Mon Sep 17 00:00:00 2001
From: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
Date: Sun, 12 Feb 2023 21:35:26 +0100
Subject: [PATCH 1/4] WIP: Noise stuff.

Signed-off-by: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
---
 assets/shaders/auto-update-shader.sh | 12 ----
 assets/shaders/math.wgsl             | 46 ++++++++++++++
 assets/shaders/value_noise.wgsl      | 43 +++++++++++++
 examples/noise/main.rs               | 95 ++++++++++++++++++++++++++++
 src/lib.rs                           |  3 +
 src/materials/mod.rs                 | 53 ++++++++++++++++
 src/plugin.rs                        |  5 +-
 7 files changed, 243 insertions(+), 14 deletions(-)
 delete mode 100644 assets/shaders/auto-update-shader.sh
 create mode 100644 assets/shaders/math.wgsl
 create mode 100644 assets/shaders/value_noise.wgsl
 create mode 100644 examples/noise/main.rs
 create mode 100644 src/materials/mod.rs

diff --git a/assets/shaders/auto-update-shader.sh b/assets/shaders/auto-update-shader.sh
deleted file mode 100644
index 3e252af..0000000
--- a/assets/shaders/auto-update-shader.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-
-for (( ; ; ))
-do
-    sed -E 's/0\.5/0\.4/g' -i pixelate.wgsl
-    touch pixelate.wgsl
-    sleep 5
-
-    sed -E 's/0\.4/0\.5/g' -i pixelate.wgsl
-    touch pixelate.wgsl
-    sleep 5
-done
diff --git a/assets/shaders/math.wgsl b/assets/shaders/math.wgsl
new file mode 100644
index 0000000..19c7d84
--- /dev/null
+++ b/assets/shaders/math.wgsl
@@ -0,0 +1,46 @@
+#define_import_path bevy_vfx_bag::math
+
+// See Mark Jarzynski and Marc Olano, Hash Functions for GPU Rendering, Journal of Computer
+// Graphics Techniques (JCGT), vol. 9, no. 3, 20–38, 2020 
+fn pcg3d(v: vec3<u32>) -> vec3<u32> {
+    var v = v * 1664525u + 1013904223u;
+
+    v.x += v.y * v.z;
+    v.y += v.z * v.x;
+    v.z += v.x * v.y;
+
+    v = v ^ (v >> 16u);
+
+    v.x += v.y*v.z;
+    v.y += v.z*v.x;
+    v.z += v.x*v.y;
+
+    return v;
+}
+
+// https://github.com/gfx-rs/naga/issues/1908
+fn ldexp_workaround(v: f32, e: f32) -> f32 {
+    return v * exp2(e);
+}
+fn ldexp_workaround2(v: vec2<f32>, e: f32) -> vec2<f32> {
+    return v * exp2(e);
+}
+
+fn hash21(point: vec2<u32>) -> u32 {
+    return pcg3d(vec3<u32>(point.xy, 0u)).x;
+}
+
+fn hash21f(point: vec2<u32>) -> f32 {
+    // https://www.pcg-random.org/using-pcg-c.html 
+    // We get a random value in a u32's range.
+    // Divide it by 1/2^32 to produce a value in the [0, 1) range.
+    return ldexp_workaround(f32(hash21(point)), -32.0);
+}
+
+fn hash22(point: vec2<u32>) -> vec2<u32> {
+    return pcg3d(vec3<u32>(point.xy, 0u)).xy;
+}
+
+fn hash22f(point: vec2<u32>) -> vec2<f32> {
+    return ldexp_workaround2(vec2<f32>(hash22(point)), -32.0);
+}
diff --git a/assets/shaders/value_noise.wgsl b/assets/shaders/value_noise.wgsl
new file mode 100644
index 0000000..5b30b97
--- /dev/null
+++ b/assets/shaders/value_noise.wgsl
@@ -0,0 +1,43 @@
+#define_import_path bevy_vfx_bag::value_noise
+#import bevy_vfx_bag::math
+
+fn value_noise(coords: vec2<f32>) -> f32 {
+    let index = vec2<u32>(floor(coords));
+    let frac = fract(coords);
+
+    // Sometimes a smoothstepped frac is used instead.
+    let interpolant = frac;
+
+    let noise_xy00 = hash21f(index + vec2(0u, 0u));
+    let noise_xy10 = hash21f(index + vec2(1u, 0u));
+    let noise_xy01 = hash21f(index + vec2(0u, 1u));
+    let noise_xy11 = hash21f(index + vec2(1u, 1u));
+
+    // Gives us the noise at the correct point in the x direction
+    // between the upper corners
+    let noise_x0_lerp = mix(f32(noise_xy00), f32(noise_xy10), interpolant.x);
+
+    // x direction lower corners
+    let noise_x1_lerp = mix(f32(noise_xy01), f32(noise_xy11), interpolant.x);
+
+    // Lastly lerp between the values found in the y direction.
+    let noise = mix(noise_x0_lerp, noise_x1_lerp, interpolant.y);
+
+    return noise;
+}
+
+struct CustomMaterial {
+    scale: f32,
+    offset_x: f32,
+    offset_y: f32,
+};
+
+@group(1) @binding(0)
+var<uniform> material: CustomMaterial;
+
+@fragment
+fn fragment(
+    #import bevy_pbr::mesh_vertex_output
+) -> @location(0) vec4<f32> {
+    return vec4<f32>(vec3(value_noise((material.scale * uv) + vec2(material.offset_x, material.offset_y))), 1.0);
+}
diff --git a/examples/noise/main.rs b/examples/noise/main.rs
new file mode 100644
index 0000000..a87b535
--- /dev/null
+++ b/examples/noise/main.rs
@@ -0,0 +1,95 @@
+#[path = "../examples_common.rs"]
+mod examples_common;
+
+use bevy::{
+    prelude::*,
+    reflect::TypeUuid,
+    render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
+};
+
+use bevy_vfx_bag::BevyVfxBagPlugin;
+
+fn main() {
+    let mut app = App::new();
+
+    app.add_plugin(examples_common::SaneDefaultsPlugin)
+        .add_plugin(BevyVfxBagPlugin::default())
+        .add_plugin(MaterialPlugin::<CustomMaterial>::default())
+        .add_startup_system(startup)
+        .add_system(update)
+        .run();
+}
+
+fn startup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<CustomMaterial>>,
+) {
+    // cube
+
+    for i in 1..=4 {
+        let i = i as f32;
+        let uv = Uv {
+            scale: i * 4.,
+            ..default()
+        };
+
+        commands.spawn(MaterialMeshBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+            transform: Transform::from_xyz(-4. + (i * 2.), 0.5, 0.0),
+            material: materials.add(CustomMaterial { uv }),
+            ..default()
+        });
+    }
+
+    // camera
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(-0.5, 0.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..default()
+    });
+}
+
+impl Material for CustomMaterial {
+    fn fragment_shader() -> ShaderRef {
+        "shaders/value_noise.wgsl".into()
+    }
+}
+
+#[derive(Debug, ShaderType, Clone)]
+struct Uv {
+    scale: f32,
+    offset_x: f32,
+    offset_y: f32,
+}
+
+impl Default for Uv {
+    fn default() -> Self {
+        Self {
+            scale: 1.,
+            offset_x: 0.,
+            offset_y: 0.,
+        }
+    }
+}
+
+// This is the struct that will be passed to your shader
+#[derive(AsBindGroup, TypeUuid, Debug, Clone, Default)]
+#[uuid = "9dc460be-ab02-11ed-905b-325096b39f47"]
+pub struct CustomMaterial {
+    #[uniform(0)]
+    uv: Uv,
+}
+
+fn update(
+    time: Res<Time>,
+    query: Query<&Handle<CustomMaterial>>,
+    mut custom_material_assets: ResMut<Assets<CustomMaterial>>,
+) {
+    for handle in query.iter() {
+        if let Some(custom_material) = custom_material_assets.get_mut(handle) {
+            let t = time.delta_seconds();
+            custom_material.uv.offset_x += 3. * t;
+            custom_material.uv.offset_y += t;
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 262ee7b..283447a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,6 +6,9 @@
 /// Post processing effects.
 pub mod post_processing;
 
+/// Materials.
+pub mod materials;
+
 mod plugin;
 
 pub use plugin::BevyVfxBagPlugin;
diff --git a/src/materials/mod.rs b/src/materials/mod.rs
new file mode 100644
index 0000000..d0f617f
--- /dev/null
+++ b/src/materials/mod.rs
@@ -0,0 +1,53 @@
+use bevy::{asset::load_internal_asset, prelude::*, reflect::TypeUuid, render::RenderApp};
+
+#[derive(Debug, Default)]
+pub(crate) struct MaterialsPlugin;
+
+pub(crate) const MATH_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 3078479269656997866);
+
+pub(crate) const VALUE_NOISE_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 2904626210061300097);
+
+impl Plugin for MaterialsPlugin {
+    fn build(&self, app: &mut App) {
+        // let render_app = app
+        //     .get_sub_app_mut(RenderApp)
+        //     .expect("Need a render app for post processing");
+
+        load_internal_asset!(
+            app,
+            MATH_SHADER_HANDLE,
+            concat!(env!("CARGO_MANIFEST_DIR"), "/assets/shaders/", "math.wgsl"),
+            Shader::from_wgsl
+        );
+
+        load_internal_asset!(
+            app,
+            VALUE_NOISE_SHADER_HANDLE,
+            concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/assets/shaders/",
+                "value_noise.wgsl"
+            ),
+            Shader::from_wgsl
+        );
+
+        // render_app
+        //     .init_resource::<DrawFunctions<PostProcessingPhaseItem>>()
+        //     .init_resource::<PostProcessingSharedBindGroups>()
+        //     .init_resource::<PostProcessingSharedLayout>()
+        //     .add_system_to_schedule(ExtractSchedule, extract_camera_phases)
+        //     .add_system(queue_post_processing_shared_bind_groups.in_set(RenderSet::Queue))
+        //     .add_system(sort_phase_system::<PostProcessingPhaseItem>.in_set(RenderSet::PhaseSort));
+
+        // app.add_plugin(blur::Plugin);
+        // app.add_plugin(chromatic_aberration::Plugin);
+        // app.add_plugin(flip::Plugin);
+        // app.add_plugin(lut::Plugin);
+        // app.add_plugin(masks::Plugin);
+        // app.add_plugin(raindrops::Plugin);
+        // app.add_plugin(pixelate::Plugin);
+        // app.add_plugin(wave::Plugin);
+    }
+}
diff --git a/src/plugin.rs b/src/plugin.rs
index 03913d9..718dd7c 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::post_processing;
+use crate::{materials, post_processing};
 
 /// The main plugin needed to use any effects.
 #[derive(Debug, Default)]
@@ -8,6 +8,7 @@ pub struct BevyVfxBagPlugin;
 
 impl Plugin for BevyVfxBagPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugin(post_processing::PostProcessingPlugin);
+        app.add_plugin(post_processing::PostProcessingPlugin)
+            .add_plugin(materials::MaterialsPlugin);
     }
 }

From 2e0de96f23d55b7311a5d7dacdc18918cb329648 Mon Sep 17 00:00:00 2001
From: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
Date: Mon, 13 Feb 2023 19:29:24 +0100
Subject: [PATCH 2/4] Fbm. Materials.

Signed-off-by: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
---
 assets/materials/fbm.wgsl         | 16 ++++++
 assets/materials/value_noise.wgsl | 17 ++++++
 assets/shaders/fbm.wgsl           | 30 +++++++++++
 assets/shaders/math.wgsl          |  7 ++-
 assets/shaders/value_noise.wgsl   | 16 ------
 examples/noise/main.rs            | 90 +++++++++++++++++++++++--------
 src/materials/mod.rs              | 31 ++++-------
 7 files changed, 145 insertions(+), 62 deletions(-)
 create mode 100644 assets/materials/fbm.wgsl
 create mode 100644 assets/materials/value_noise.wgsl
 create mode 100644 assets/shaders/fbm.wgsl

diff --git a/assets/materials/fbm.wgsl b/assets/materials/fbm.wgsl
new file mode 100644
index 0000000..2cf59c4
--- /dev/null
+++ b/assets/materials/fbm.wgsl
@@ -0,0 +1,16 @@
+#import bevy_vfx_bag::fbm
+
+struct CustomMaterial {
+    scale: f32,
+    offset_x: f32,
+    offset_y: f32,
+};
+@group(1) @binding(0)
+var<uniform> material: CustomMaterial;
+
+@fragment
+fn fragment(
+    #import bevy_pbr::mesh_vertex_output
+) -> @location(0) vec4<f32> {
+    return vec4<f32>(vec3(fbm((material.scale * uv) + vec2(material.offset_x, material.offset_y))), 1.0);
+}
diff --git a/assets/materials/value_noise.wgsl b/assets/materials/value_noise.wgsl
new file mode 100644
index 0000000..8c1fe36
--- /dev/null
+++ b/assets/materials/value_noise.wgsl
@@ -0,0 +1,17 @@
+#import bevy_vfx_bag::value_noise
+
+struct CustomMaterial {
+    scale: f32,
+    offset_x: f32,
+    offset_y: f32,
+};
+@group(1) @binding(0)
+var<uniform> material: CustomMaterial;
+
+@fragment
+fn fragment(
+    #import bevy_pbr::mesh_vertex_output
+) -> @location(0) vec4<f32> {
+    let noise = value_noise((material.scale * uv) + vec2(material.offset_x, material.offset_y));
+    return vec4<f32>(vec3(noise), 1.0);
+}
diff --git a/assets/shaders/fbm.wgsl b/assets/shaders/fbm.wgsl
new file mode 100644
index 0000000..632818c
--- /dev/null
+++ b/assets/shaders/fbm.wgsl
@@ -0,0 +1,30 @@
+#define_import_path bevy_vfx_bag::fbm
+#import bevy_vfx_bag::value_noise
+
+/*
+TODO:
+- Expose parameters
+- Consider if parameters should be shader preprocessor values
+- The noise used should be defined by a shader preprocessor definition
+*/
+
+const NUM_OCTAVES: u32 = 8u;
+const hurst: f32 = 1.0;
+
+fn fbm(coords: vec2<f32>) -> f32 {
+    let gain = exp2(-hurst); 
+    var result = 0.0;
+
+    var amplitude = 1.0;
+    var frequency = 1.0;
+
+    for (var i: u32 = 0u; i < NUM_OCTAVES; i++) {
+        let noise = value_noise(coords * frequency);
+        result += amplitude * noise;
+
+        amplitude *= gain;
+        frequency *= 2.041002312;
+    }
+
+    return result;
+}
\ No newline at end of file
diff --git a/assets/shaders/math.wgsl b/assets/shaders/math.wgsl
index 19c7d84..13f23e3 100644
--- a/assets/shaders/math.wgsl
+++ b/assets/shaders/math.wgsl
@@ -34,7 +34,9 @@ fn hash21f(point: vec2<u32>) -> f32 {
     // https://www.pcg-random.org/using-pcg-c.html 
     // We get a random value in a u32's range.
     // Divide it by 1/2^32 to produce a value in the [0, 1) range.
-    return ldexp_workaround(f32(hash21(point)), -32.0);
+    // Then massage it to get the desired [-1, 1) range.
+    let noise = ldexp_workaround(f32(hash21(point)), -32.0);
+    return -1.0 + 2.0 * noise;
 }
 
 fn hash22(point: vec2<u32>) -> vec2<u32> {
@@ -42,5 +44,6 @@ fn hash22(point: vec2<u32>) -> vec2<u32> {
 }
 
 fn hash22f(point: vec2<u32>) -> vec2<f32> {
-    return ldexp_workaround2(vec2<f32>(hash22(point)), -32.0);
+    let noise = ldexp_workaround2(vec2<f32>(hash22(point)), -32.0);
+    return vec2(-1.0) + (2.0 * noise);
 }
diff --git a/assets/shaders/value_noise.wgsl b/assets/shaders/value_noise.wgsl
index 5b30b97..74972a6 100644
--- a/assets/shaders/value_noise.wgsl
+++ b/assets/shaders/value_noise.wgsl
@@ -25,19 +25,3 @@ fn value_noise(coords: vec2<f32>) -> f32 {
 
     return noise;
 }
-
-struct CustomMaterial {
-    scale: f32,
-    offset_x: f32,
-    offset_y: f32,
-};
-
-@group(1) @binding(0)
-var<uniform> material: CustomMaterial;
-
-@fragment
-fn fragment(
-    #import bevy_pbr::mesh_vertex_output
-) -> @location(0) vec4<f32> {
-    return vec4<f32>(vec3(value_noise((material.scale * uv) + vec2(material.offset_x, material.offset_y))), 1.0);
-}
diff --git a/examples/noise/main.rs b/examples/noise/main.rs
index a87b535..1b5e36e 100644
--- a/examples/noise/main.rs
+++ b/examples/noise/main.rs
@@ -14,19 +14,21 @@ fn main() {
 
     app.add_plugin(examples_common::SaneDefaultsPlugin)
         .add_plugin(BevyVfxBagPlugin::default())
-        .add_plugin(MaterialPlugin::<CustomMaterial>::default())
+        .add_plugin(MaterialPlugin::<ValueNoise>::default())
+        .add_plugin(MaterialPlugin::<Fbm>::default())
         .add_startup_system(startup)
-        .add_system(update)
+        .add_system(update_value_noise)
+        .add_system(update_fbm)
         .run();
 }
 
 fn startup(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<CustomMaterial>>,
+    mut noise_materials: ResMut<Assets<ValueNoise>>,
+    mut fbm_materials: ResMut<Assets<Fbm>>,
 ) {
-    // cube
-
+    // noise cubes
     for i in 1..=4 {
         let i = i as f32;
         let uv = Uv {
@@ -37,21 +39,59 @@ fn startup(
         commands.spawn(MaterialMeshBundle {
             mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
             transform: Transform::from_xyz(-4. + (i * 2.), 0.5, 0.0),
-            material: materials.add(CustomMaterial { uv }),
+            material: noise_materials.add(ValueNoise { uv }),
+            ..default()
+        });
+    }
+
+    // fbm cubes
+    for i in 1..=4 {
+        let i = i as f32;
+        let uv = Uv {
+            scale: i * 4.,
+            ..default()
+        };
+
+        commands.spawn(MaterialMeshBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+            transform: Transform::from_xyz(-4. + (i * 2.), -1.0, 0.0),
+            material: fbm_materials.add(Fbm { uv }),
             ..default()
         });
     }
 
     // camera
     commands.spawn(Camera3dBundle {
-        transform: Transform::from_xyz(-0.5, 0.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
+        transform: Transform::from_xyz(-0.5, 0.5, 7.0).looking_at(Vec3::ZERO, Vec3::Y),
         ..default()
     });
 }
 
-impl Material for CustomMaterial {
-    fn fragment_shader() -> ShaderRef {
-        "shaders/value_noise.wgsl".into()
+fn update_value_noise(
+    time: Res<Time>,
+    query: Query<&Handle<ValueNoise>>,
+    mut custom_material_assets: ResMut<Assets<ValueNoise>>,
+) {
+    for handle in query.iter() {
+        if let Some(custom_material) = custom_material_assets.get_mut(handle) {
+            let t = time.delta_seconds();
+            custom_material.uv.offset_x += 3. * t;
+            custom_material.uv.offset_y += t;
+        }
+    }
+}
+
+fn update_fbm(
+    time: Res<Time>,
+    query: Query<&Handle<Fbm>>,
+    mut custom_material_assets: ResMut<Assets<Fbm>>,
+) {
+    for handle in query.iter() {
+        if let Some(custom_material) = custom_material_assets.get_mut(handle) {
+            let t = time.delta_seconds();
+            custom_material.uv.offset_x += 3. * t;
+            custom_material.uv.offset_y += t;
+        }
     }
 }
 
@@ -72,24 +112,28 @@ impl Default for Uv {
     }
 }
 
-// This is the struct that will be passed to your shader
 #[derive(AsBindGroup, TypeUuid, Debug, Clone, Default)]
 #[uuid = "9dc460be-ab02-11ed-905b-325096b39f47"]
-pub struct CustomMaterial {
+pub struct ValueNoise {
     #[uniform(0)]
     uv: Uv,
 }
 
-fn update(
-    time: Res<Time>,
-    query: Query<&Handle<CustomMaterial>>,
-    mut custom_material_assets: ResMut<Assets<CustomMaterial>>,
-) {
-    for handle in query.iter() {
-        if let Some(custom_material) = custom_material_assets.get_mut(handle) {
-            let t = time.delta_seconds();
-            custom_material.uv.offset_x += 3. * t;
-            custom_material.uv.offset_y += t;
-        }
+impl Material for ValueNoise {
+    fn fragment_shader() -> ShaderRef {
+        "materials/value_noise.wgsl".into()
+    }
+}
+
+#[derive(AsBindGroup, TypeUuid, Debug, Clone, Default)]
+#[uuid = "89801a24-abc2-11ed-8f97-325096b39f47"]
+pub struct Fbm {
+    #[uniform(0)]
+    uv: Uv,
+}
+
+impl Material for Fbm {
+    fn fragment_shader() -> ShaderRef {
+        "materials/fbm.wgsl".into()
     }
 }
diff --git a/src/materials/mod.rs b/src/materials/mod.rs
index d0f617f..0d1075b 100644
--- a/src/materials/mod.rs
+++ b/src/materials/mod.rs
@@ -1,4 +1,4 @@
-use bevy::{asset::load_internal_asset, prelude::*, reflect::TypeUuid, render::RenderApp};
+use bevy::{asset::load_internal_asset, prelude::*, reflect::TypeUuid};
 
 #[derive(Debug, Default)]
 pub(crate) struct MaterialsPlugin;
@@ -9,12 +9,11 @@ pub(crate) const MATH_SHADER_HANDLE: HandleUntyped =
 pub(crate) const VALUE_NOISE_SHADER_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 2904626210061300097);
 
+pub(crate) const FBM_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 6883246438893588577);
+
 impl Plugin for MaterialsPlugin {
     fn build(&self, app: &mut App) {
-        // let render_app = app
-        //     .get_sub_app_mut(RenderApp)
-        //     .expect("Need a render app for post processing");
-
         load_internal_asset!(
             app,
             MATH_SHADER_HANDLE,
@@ -33,21 +32,11 @@ impl Plugin for MaterialsPlugin {
             Shader::from_wgsl
         );
 
-        // render_app
-        //     .init_resource::<DrawFunctions<PostProcessingPhaseItem>>()
-        //     .init_resource::<PostProcessingSharedBindGroups>()
-        //     .init_resource::<PostProcessingSharedLayout>()
-        //     .add_system_to_schedule(ExtractSchedule, extract_camera_phases)
-        //     .add_system(queue_post_processing_shared_bind_groups.in_set(RenderSet::Queue))
-        //     .add_system(sort_phase_system::<PostProcessingPhaseItem>.in_set(RenderSet::PhaseSort));
-
-        // app.add_plugin(blur::Plugin);
-        // app.add_plugin(chromatic_aberration::Plugin);
-        // app.add_plugin(flip::Plugin);
-        // app.add_plugin(lut::Plugin);
-        // app.add_plugin(masks::Plugin);
-        // app.add_plugin(raindrops::Plugin);
-        // app.add_plugin(pixelate::Plugin);
-        // app.add_plugin(wave::Plugin);
+        load_internal_asset!(
+            app,
+            FBM_SHADER_HANDLE,
+            concat!(env!("CARGO_MANIFEST_DIR"), "/assets/shaders/", "fbm.wgsl"),
+            Shader::from_wgsl
+        );
     }
 }

From f4f8e805dfb39b9a4a648b5a6d001202e49876eb Mon Sep 17 00:00:00 2001
From: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
Date: Mon, 13 Feb 2023 23:08:33 +0100
Subject: [PATCH 3/4] Vornoi init

Signed-off-by: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
---
 assets/materials/fbm.wgsl         |  4 +--
 assets/materials/value_noise.wgsl |  4 +--
 assets/materials/voronoi.wgsl     | 42 ++++++++++++++++++++++++++
 examples/noise/main.rs            | 50 +++++++++++++++++++++++++++++--
 4 files changed, 94 insertions(+), 6 deletions(-)
 create mode 100644 assets/materials/voronoi.wgsl

diff --git a/assets/materials/fbm.wgsl b/assets/materials/fbm.wgsl
index 2cf59c4..70806d1 100644
--- a/assets/materials/fbm.wgsl
+++ b/assets/materials/fbm.wgsl
@@ -1,12 +1,12 @@
 #import bevy_vfx_bag::fbm
 
-struct CustomMaterial {
+struct Material {
     scale: f32,
     offset_x: f32,
     offset_y: f32,
 };
 @group(1) @binding(0)
-var<uniform> material: CustomMaterial;
+var<uniform> material: Material;
 
 @fragment
 fn fragment(
diff --git a/assets/materials/value_noise.wgsl b/assets/materials/value_noise.wgsl
index 8c1fe36..17e217f 100644
--- a/assets/materials/value_noise.wgsl
+++ b/assets/materials/value_noise.wgsl
@@ -1,12 +1,12 @@
 #import bevy_vfx_bag::value_noise
 
-struct CustomMaterial {
+struct Material {
     scale: f32,
     offset_x: f32,
     offset_y: f32,
 };
 @group(1) @binding(0)
-var<uniform> material: CustomMaterial;
+var<uniform> material: Material;
 
 @fragment
 fn fragment(
diff --git a/assets/materials/voronoi.wgsl b/assets/materials/voronoi.wgsl
new file mode 100644
index 0000000..5b57850
--- /dev/null
+++ b/assets/materials/voronoi.wgsl
@@ -0,0 +1,42 @@
+#import bevy_vfx_bag::math
+
+struct Material {
+    scale: f32,
+    offset_x: f32,
+    offset_y: f32,
+};
+@group(1) @binding(0)
+var<uniform> material: Material;
+
+@fragment
+fn fragment(
+    #import bevy_pbr::mesh_vertex_output
+) -> @location(0) vec4<f32> {
+    var uv = uv * 8.;
+    let id = vec2<i32>(1. + floor(uv));
+    let f = -0.5 + fract(uv);
+
+    var min_dist = 10.;
+
+    // If the wrapping gets strange we can always bias with a +1
+    for (var y: i32 = -1; y <= 1; y++) {
+        for (var x: i32 = -1; x <= 1; x++) {
+            let offset = vec2(x, y);
+
+            // Random 2D vector in range (-0.5, +0.5)
+            let random2d = hash22f(vec2<u32>(id + offset)) / 2.;
+            let p = vec2<f32>(offset) + sin(random2d * material.offset_x);
+
+            let dist = length(f - p);
+
+            if (dist < min_dist) {
+                min_dist = dist;
+            }
+        }
+    }
+
+    min_dist = 1. - min_dist;
+    min_dist = smoothstep(0.5, 1.0, min_dist);
+
+    return vec4<f32>(min_dist, min_dist * 2., 0.0, 1.0);
+}
diff --git a/examples/noise/main.rs b/examples/noise/main.rs
index 1b5e36e..b822fb4 100644
--- a/examples/noise/main.rs
+++ b/examples/noise/main.rs
@@ -16,9 +16,11 @@ fn main() {
         .add_plugin(BevyVfxBagPlugin::default())
         .add_plugin(MaterialPlugin::<ValueNoise>::default())
         .add_plugin(MaterialPlugin::<Fbm>::default())
+        .add_plugin(MaterialPlugin::<Voronoi>::default())
         .add_startup_system(startup)
         .add_system(update_value_noise)
         .add_system(update_fbm)
+        .add_system(update_voronoi)
         .run();
 }
 
@@ -27,6 +29,7 @@ fn startup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut noise_materials: ResMut<Assets<ValueNoise>>,
     mut fbm_materials: ResMut<Assets<Fbm>>,
+    mut voronoi_materials: ResMut<Assets<Voronoi>>,
 ) {
     // noise cubes
     for i in 1..=4 {
@@ -38,7 +41,7 @@ fn startup(
 
         commands.spawn(MaterialMeshBundle {
             mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
-            transform: Transform::from_xyz(-4. + (i * 2.), 0.5, 0.0),
+            transform: Transform::from_xyz(-4. + (i * 2.), 1.5, 0.0),
             material: noise_materials.add(ValueNoise { uv }),
             ..default()
         });
@@ -54,12 +57,28 @@ fn startup(
 
         commands.spawn(MaterialMeshBundle {
             mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
-            transform: Transform::from_xyz(-4. + (i * 2.), -1.0, 0.0),
+            transform: Transform::from_xyz(-4. + (i * 2.), 0.0, 0.0),
             material: fbm_materials.add(Fbm { uv }),
             ..default()
         });
     }
 
+    // voronoi cubes
+    for i in 1..=4 {
+        let i = i as f32;
+        let uv = Uv {
+            scale: i * 4.,
+            ..default()
+        };
+
+        commands.spawn(MaterialMeshBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+            transform: Transform::from_xyz(-4. + (i * 2.), -1.5, 0.0),
+            material: voronoi_materials.add(Voronoi { uv }),
+            ..default()
+        });
+    }
+
     // camera
     commands.spawn(Camera3dBundle {
         transform: Transform::from_xyz(-0.5, 0.5, 7.0).looking_at(Vec3::ZERO, Vec3::Y),
@@ -95,6 +114,20 @@ fn update_fbm(
     }
 }
 
+fn update_voronoi(
+    time: Res<Time>,
+    query: Query<&Handle<Voronoi>>,
+    mut custom_material_assets: ResMut<Assets<Voronoi>>,
+) {
+    for handle in query.iter() {
+        if let Some(custom_material) = custom_material_assets.get_mut(handle) {
+            let t = time.delta_seconds();
+            custom_material.uv.offset_x += 3. * t;
+            custom_material.uv.offset_y += t;
+        }
+    }
+}
+
 #[derive(Debug, ShaderType, Clone)]
 struct Uv {
     scale: f32,
@@ -137,3 +170,16 @@ impl Material for Fbm {
         "materials/fbm.wgsl".into()
     }
 }
+
+#[derive(AsBindGroup, TypeUuid, Debug, Clone, Default)]
+#[uuid = "c3321c76-abe6-11ed-938d-325096b39f47"]
+pub struct Voronoi {
+    #[uniform(0)]
+    uv: Uv,
+}
+
+impl Material for Voronoi {
+    fn fragment_shader() -> ShaderRef {
+        "materials/voronoi.wgsl".into()
+    }
+}

From 53fcb46430b9dd4a22eea705004e8765ba6357a1 Mon Sep 17 00:00:00 2001
From: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
Date: Wed, 22 Feb 2023 10:05:17 +0100
Subject: [PATCH 4/4] WIP, just a check-in before format hdd...

Signed-off-by: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
---
 assets/materials/voronoi.wgsl |  73 +++++++++++++++++-----
 assets/shaders/marble.wgsl    | 111 ++++++++++++++++++++++++++++++++++
 examples/examples_common.rs   |   8 ++-
 examples/noise/main.rs        |  11 ++++
 src/post_processing/mod.rs    |   3 +-
 5 files changed, 188 insertions(+), 18 deletions(-)
 create mode 100644 assets/shaders/marble.wgsl

diff --git a/assets/materials/voronoi.wgsl b/assets/materials/voronoi.wgsl
index 5b57850..2a4de97 100644
--- a/assets/materials/voronoi.wgsl
+++ b/assets/materials/voronoi.wgsl
@@ -8,26 +8,40 @@ struct Material {
 @group(1) @binding(0)
 var<uniform> material: Material;
 
-@fragment
-fn fragment(
-    #import bevy_pbr::mesh_vertex_output
-) -> @location(0) vec4<f32> {
-    var uv = uv * 8.;
-    let id = vec2<i32>(1. + floor(uv));
-    let f = -0.5 + fract(uv);
+fn voronoi(
+    uv: vec2<f32>
+) -> f32 {
+    var uv = uv * material.scale;
+    let id = vec2<i32>(floor(uv));
+
+    let cell_space = -0.5 + fract(uv);
 
-    var min_dist = 10.;
+    var min_dist = 10.0;
 
-    // If the wrapping gets strange we can always bias with a +1
     for (var y: i32 = -1; y <= 1; y++) {
         for (var x: i32 = -1; x <= 1; x++) {
             let offset = vec2(x, y);
 
-            // Random 2D vector in range (-0.5, +0.5)
-            let random2d = hash22f(vec2<u32>(id + offset)) / 2.;
-            let p = vec2<f32>(offset) + sin(random2d * material.offset_x);
+            // Random 2D vector in range (-0.5, +0.5).
+            // Note that the strategy is to go from normal UVs (0,0) -> (1,1) to something scaled, like
+            // (0,0) -> (10,10) (for example).
+            // We floor that to get integer IDs.
+            // Then we add an offset in order to index our neighbours.
+            let neighbour_random_point = hash22f(vec2<u32>(id + offset)) / 2.;
 
-            let dist = length(f - p);
+            // So now we have a random 2D point which is deterministic with regards
+            // to the ID of the cell.
+            // What we care about though is how far away this point is relative to _this_ cell.
+            // Therefore we have to add the offset of the cell with the point in question to realize
+            // that distance.
+            // var p = sin(random2d * vec2(material.offset_x, material.offset_y)) + vec2<f32>(offset);
+            // var p = sin(neighbour_random_point * vec2(material.offset_x, material.offset_y)) + vec2<f32>(offset);
+            var p = sin(neighbour_random_point) + vec2<f32>(offset);
+            // var p = random2d + vec2<f32>(offset);
+
+            // p += sin(vec2(material.offset_x, material.offset_y)) / 2.;
+
+            let dist = length(cell_space - p);
 
             if (dist < min_dist) {
                 min_dist = dist;
@@ -35,8 +49,35 @@ fn fragment(
         }
     }
 
-    min_dist = 1. - min_dist;
-    min_dist = smoothstep(0.5, 1.0, min_dist);
+    // min_dist = 1. - min(1., min_dist);
+    min_dist = smoothstep(0.31, 1.0, min_dist);
+
+    return min_dist;
+}
+
+@fragment
+fn fragment(
+    #import bevy_pbr::mesh_vertex_output
+) -> @location(0) vec4<f32> {
+    // let v = voronoi(uv);
+    // return vec4<f32>(v * 0.1, v * 4., v, 1.0);
+
+    let uv = uv * 10.;
+
+    let xoff = sin(material.offset_x / 2.) / 2.1;
+    let yoff = cos(material.offset_x / 3.) / 2.1;
+    let off = vec2(xoff, yoff);
+
+    let a = vec2(3. + xoff);
+    let b = vec2(6., 6. + yoff);
+
+    let auv = -a + uv;
+    let ab = -a + b;
+
+    let h = clamp(dot(auv, normalize(ab)) / length(ab), 0., 1.);
+
+    let d = smoothstep(0.5, 0.6, length(-auv + h * ab));
+    // let d = length(h * ab);
 
-    return vec4<f32>(min_dist, min_dist * 2., 0.0, 1.0);
+    return vec4<f32>(vec3(d), 1.0);
 }
diff --git a/assets/shaders/marble.wgsl b/assets/shaders/marble.wgsl
new file mode 100644
index 0000000..580048d
--- /dev/null
+++ b/assets/shaders/marble.wgsl
@@ -0,0 +1,111 @@
+/*
+From: https://www.shadertoy.com/view/Xs3fR4
+
+// variant of Vorocracks: https://shadertoy.com/view/lsVyRy
+// integrated with cracks here: https://www.shadertoy.com/view/Xd3fRN
+
+
+float ofs = 0.;
+
+
+float RATIO = 1.,              // stone length/width ratio  
+      CRACK_depth = 2.,
+      CRACK_zebra_scale = 1.,  // fractal shape of the fault zebra
+      CRACK_zebra_amp = 0.34,
+      CRACK_profile = 1.,      // fault vertical shape  1.  .2 
+      CRACK_slope = 50.,       //                      10.  1.4
+      CRACK_width = .001;
+    
+
+// === Voronoi =====================================================
+// --- Base Voronoi. inspired by https://www.shadertoy.com/view/MslGD8
+
+#define hash22(p)  fract( 18.5453 * sin( p * mat2(127.1,311.7,269.5,183.3)) )
+
+
+// --- Voronoi distance to borders. inspired by https://www.shadertoy.com/view/ldl3W8
+vec3 voronoiB( vec2 u )  // returns len + id
+{
+    vec2 iu = floor(u), C, P;
+	float m = 1e9,d;
+
+    for( int k=0; k < 9; k++ ) {
+        vec2  p = iu + vec2(k%3-1,k/3-1),
+
+              o = hash22(p),
+      	      r = p - u + o;
+		d = dot(r,r);
+        if( d < m ) m = d, C = p-iu, P = r;
+    }
+
+    m = 1e9;
+    
+    for( int k=0; k < 25; k++ ) {
+        vec2 p = iu+C + vec2(k%5-2,k/5-2),
+		     o = hash22(p),
+             r = p-u + o;
+
+        if( dot(P-r,P-r)>1e-5 )
+        m = min( m, .5*dot( (P+r), normalize(r-P) ) );
+    }
+
+    return vec3( m, P+u );
+}
+
+// === pseudo Perlin noise =============================================
+#define rot(a) mat2(cos(a),-sin(a),sin(a),cos(a))
+int MOD = 1;  // type of Perlin noise
+    
+// --- 2D
+#define hash21(p) fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453123)
+float noise2(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p); f = f*f*(3.-2.*f); // smoothstep
+
+    float v= mix( mix(hash21(i+vec2(0,0)),hash21(i+vec2(1,0)),f.x),
+                  mix(hash21(i+vec2(0,1)),hash21(i+vec2(1,1)),f.x), f.y);
+	return   MOD==0 ? v
+	       : MOD==1 ? 2.*v-1.
+           : MOD==2 ? abs(2.*v-1.)
+                    : 1.-abs(2.*v-1.);
+}
+
+
+#define noise22(p) vec2(noise2(p),noise2(p+17.7))
+vec2 fbm22(vec2 p) {
+    vec2 v = vec2(0);
+    float a = .5;
+    mat2 R = rot(0.5);
+
+    for (int i = 0; i < 6; i++, p*=2.,a/=2.) 
+        p *= R,
+        v += a * noise22(p);
+
+    return v;
+}
+
+    
+// ======================================================
+
+void mainImage( out vec4 O, vec2 U )
+{
+    U *= 3./iResolution.y;
+    U.x += iTime;                                     // for demo
+    
+    vec3 H0;
+    O-=O;
+
+    for(float i=0.; i<CRACK_depth ; i++) {
+        vec2 V =  U / vec2(RATIO,2),                  // voronoi cell shape
+             D = CRACK_zebra_amp * fbm22(U/CRACK_zebra_scale) * CRACK_zebra_scale;
+        vec3  H = voronoiB( V + D ); if (i==0.) H0=H;
+        float d = H.x;                                // distance to cracks
+                                            // cracks
+        d = min( 1., CRACK_slope * pow(max(0.,d-CRACK_width),CRACK_profile) );
+  
+        O += vec4(1.-d) / exp2(i);
+        U *= 1.5 * rot(.37);
+    }
+}
+
+*/
\ No newline at end of file
diff --git a/examples/examples_common.rs b/examples/examples_common.rs
index 9d15470..32d4517 100644
--- a/examples/examples_common.rs
+++ b/examples/examples_common.rs
@@ -141,7 +141,13 @@ mod shapes {
 
         // ground plane
         commands.spawn(PbrBundle {
-            mesh: meshes.add(shape::Plane { size: 50. }.into()),
+            mesh: meshes.add(
+                shape::Plane {
+                    size: 50.,
+                    ..default()
+                }
+                .into(),
+            ),
             material: materials.add(Color::SILVER.into()),
             ..default()
         });
diff --git a/examples/noise/main.rs b/examples/noise/main.rs
index b822fb4..baa9e88 100644
--- a/examples/noise/main.rs
+++ b/examples/noise/main.rs
@@ -31,6 +31,7 @@ fn startup(
     mut fbm_materials: ResMut<Assets<Fbm>>,
     mut voronoi_materials: ResMut<Assets<Voronoi>>,
 ) {
+    /*
     // noise cubes
     for i in 1..=4 {
         let i = i as f32;
@@ -78,6 +79,16 @@ fn startup(
             ..default()
         });
     }
+     */
+
+    let uv = Uv { ..default() };
+
+    commands.spawn(MaterialMeshBundle {
+        mesh: meshes.add(Mesh::from(shape::Cube { size: 3.8 })),
+        transform: Transform::from_xyz(0.0, 0.0, 0.0),
+        material: voronoi_materials.add(Voronoi { uv }),
+        ..default()
+    });
 
     // camera
     commands.spawn(Camera3dBundle {
diff --git a/src/post_processing/mod.rs b/src/post_processing/mod.rs
index 49891cd..4b1e55a 100644
--- a/src/post_processing/mod.rs
+++ b/src/post_processing/mod.rs
@@ -166,7 +166,7 @@ pub(crate) fn render_pipeline_descriptor(
 ) -> RenderPipelineDescriptor {
     RenderPipelineDescriptor {
         label: Some(format!("{label} Render Pipeline").into()),
-        layout: Some(vec![shared_layout.clone(), uniform_layout.clone()]),
+        layout: vec![shared_layout.clone(), uniform_layout.clone()],
         vertex: fullscreen_shader_vertex_state(),
         primitive: PrimitiveState::default(),
         depth_stencil: None,
@@ -177,6 +177,7 @@ pub(crate) fn render_pipeline_descriptor(
             entry_point: "fragment".into(),
             targets: vec![Some(TextureFormat::bevy_default().into())],
         }),
+        push_constant_ranges: vec![],
     }
 }