From 7906a0303109bfeb0c2e41e351ce21464ff1e778 Mon Sep 17 00:00:00 2001
From: Torstein Grindvik <52322338+torsteingrindvik@users.noreply.github.com>
Date: Sat, 29 Oct 2022 16:35:45 +0200
Subject: [PATCH] Bug fixes, plugin passthrough, documentation updates.. (#55)

- Add limitations section in readme
- Add breakout Bevy example showcase in readme
- Fix LUT shader: Green and blue channels were swapped
- Allow added plugins to be skipped via a passthrough functionality
- Add LUTs when not feature dev such that external users may use them. Also list the available ones in docs.
- Add missing raindrops tga when not feature dev
- Fix minor doc issues:
    - Copy pasted text
    - Hide macros not meant to be used externally

Signed-off-by: Torstein Grindvik <torstein.grindvik@nordicsemi.no>
---
 .github/workflows/basics.yml             |  30 ++--
 Cargo.toml                               |   1 +
 README.md                                |  37 ++++-
 assets/shaders/blur.wgsl                 |  13 +-
 assets/shaders/chromatic-aberration.wgsl |  13 +-
 assets/shaders/flip.wgsl                 |  15 +-
 assets/shaders/lut.wgsl                  |  23 +--
 assets/shaders/masks.wgsl                |  14 +-
 assets/shaders/pixelate.wgsl             |  14 +-
 assets/shaders/raindrops.wgsl            |  14 +-
 assets/shaders/wave.wgsl                 |  14 +-
 examples/examples_common.rs              |  22 +--
 examples/lut/main.rs                     |  74 +++------
 examples/pixelate/main.rs                |  12 +-
 examples/raindrops/main.rs               |  11 +-
 examples/trex/main.rs                    |  59 +++++++
 examples/underwater/main.rs              |   2 +-
 src/image.rs                             |   2 +-
 src/image/blur.rs                        |  55 ++++++-
 src/image/chromatic_aberration.rs        |  53 ++++++-
 src/image/flip.rs                        |  46 +++++-
 src/image/lut/mod.rs                     | 186 ++++++++++++++++++++---
 src/image/lut/neutral.png                | Bin 4328 -> 0 bytes
 src/image/mask.rs                        |  46 +++++-
 src/image/pixelate.rs                    |  52 ++++++-
 src/image/{rainrops.rs => raindrops.rs}  |  82 ++++++++--
 src/image/wave.rs                        |  55 ++++++-
 src/lib.rs                               |  47 +++++-
 src/passthrough.wgsl                     |  19 +++
 29 files changed, 786 insertions(+), 225 deletions(-)
 create mode 100644 examples/trex/main.rs
 delete mode 100644 src/image/lut/neutral.png
 rename src/image/{rainrops.rs => raindrops.rs} (67%)
 create mode 100644 src/passthrough.wgsl

diff --git a/.github/workflows/basics.yml b/.github/workflows/basics.yml
index 3d09871..a31f0ba 100644
--- a/.github/workflows/basics.yml
+++ b/.github/workflows/basics.yml
@@ -41,21 +41,21 @@ jobs:
           command: check
           args: --all-targets --features dev
 
-  test:
-    name: Test Suite
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - name: Install alsa and udev
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
+  # test:
+  #   name: Test Suite
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - uses: actions/checkout@v2
+  #     - uses: actions-rs/toolchain@v1
+  #       with:
+  #         profile: minimal
+  #         toolchain: stable
+  #         override: true
+  #     - name: Install alsa and udev
+  #       run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
+  #     - uses: actions-rs/cargo@v1
+  #       with:
+  #         command: test
 
   fmt:
     name: Rustfmt
diff --git a/Cargo.toml b/Cargo.toml
index bc198c1..45ef8d2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,6 +46,7 @@ alsa = "=0.6.0"
 
 [dev-dependencies]
 bevy = { git = "https://github.com/bevyengine/bevy", features = ["tga"] }
+# bevy = { path = "../bevy", features = ["tga"] }
 
 color-eyre = "0.6"
 image = "0.24"
diff --git a/README.md b/README.md
index 68a4e49..4742517 100644
--- a/README.md
+++ b/README.md
@@ -2,9 +2,23 @@
 
 This crate has an assortment of effects easily applied to Bevy apps via plugins.
 
-## Getting started
+Here is a showcase made by adding some visual effects to Bevy's breakout example.
+Note that the game itself is not modified except visually.
+
+[Breakout Video](https://user-images.githubusercontent.com/52322338/198832540-a1a2fa00-8c75-4f55-a3e7-b4ce18fef958.mp4)
+
+The effects added in the above are:
 
-### Bevy compatibility
+- A raindrop effect (due to effects applied after this one it gives the impression of static noise across the screen).
+- Chromatic aberration.
+- Waves. This effect causes the general "waviness" seen as well as the collision shake effect.
+- A CRT mask. This changes the edges of the screen to resemeble a CRT.
+- Pixelation. This pixelates the image. The demo increases this effect slightly each time a collision happens, but it's a bit hard to notice due to the short length of the video.
+- Color grading. A color lookup texture is applied, which changes the color output accordingly.
+
+Scroll down to see videos of the examples in contained in this repo.
+
+## Bevy compatibility
 
 When adding this crate as a dependency in your project,
 the Bevy version you use will need to match up according to the
@@ -14,7 +28,7 @@ following table:
 |---|---|
 |0.1 (unreleased)|0.9 (unreleased)|
 
-### In your code
+## Getting started
 
 The general strategy is:
 
@@ -48,9 +62,15 @@ fn update(mut flip: ResMut<Flip>) {
 }
 ```
 
+## Limitations
+
+- You can only use a single camera as the source for effects.
+- You cannot change the order of applied effects at runtime- this is decided by plugin insertion order when making the `App`.
+- You can toggle effects off/on at runtime- but the shaders will still run. They simply pass through the input image to the output, but this requires a texture sample. Therefore there is likely a slight performance cost for added-but-disabled effects.
+
 ## Examples
 
-All videos are captured from running the [examples](https://github.com/torsteingrindvik/bevy-vfx-bag/tree/main/examples).
+All videos below are captured from running the [examples](https://github.com/torsteingrindvik/bevy-vfx-bag/tree/main/examples).
 
 Do `cargo r --example` in this repository to get a list of examples you may run.
 Some examples use keyboard/mouse input to change parameters at runtime as well.
@@ -123,6 +143,14 @@ Not shown is changing the radius, and changing the color of the vignette.
 
 [Vignette Example Video](https://user-images.githubusercontent.com/52322338/195917174-0be12446-d527-4d81-8e0d-24370b8bdd03.mp4)
 
+### T-Rex
+
+Shows another use of the wave effect.
+By having a violent wave effect we can simulate something like the earth shaking due to something
+big approaching by toggling the effect in intervals.
+
+[T-Rex Example Video](https://user-images.githubusercontent.com/52322338/198832244-4898bbe9-4b24-4ddb-a5d5-665f3ecc71e3.mp4)
+
 ### Underwater
 
 Underwater (ish) effect.
@@ -145,4 +173,3 @@ which might be achieved by having a high number of waves at high speed with low
 and quickly dampening those parameters to zero so the effect ends.
 
 [Wave Example Video](https://user-images.githubusercontent.com/52322338/195917192-461fd2a1-8bdf-4671-bfce-a1182de41fb1.mp4)
-
diff --git a/assets/shaders/blur.wgsl b/assets/shaders/blur.wgsl
index e9c67b5..48b5598 100644
--- a/assets/shaders/blur.wgsl
+++ b/assets/shaders/blur.wgsl
@@ -37,13 +37,10 @@ fn s_blurred(uv: vec2<f32>) -> vec3<f32> {
         ;
 }
 
-@fragment
-fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
-) -> @location(0) vec4<f32> {
-    let uv = coords_to_viewport_uv(position.xy, view.viewport);
-
+fn fragment_impl(
+    position: vec4<f32>,
+    uv: vec2<f32>
+) -> vec4<f32> {
     let original = s(uv);
     let blurred = s_blurred(uv);
 
@@ -51,3 +48,5 @@ fn fragment(
 
     return vec4<f32>(output, 1.0);
 }
+
+#import bevy_vfx_bag::post_processing_passthrough
diff --git a/assets/shaders/chromatic-aberration.wgsl b/assets/shaders/chromatic-aberration.wgsl
index 7ec02d1..836cf7b 100644
--- a/assets/shaders/chromatic-aberration.wgsl
+++ b/assets/shaders/chromatic-aberration.wgsl
@@ -21,13 +21,10 @@ struct ChromaticAberration {
 @group(1) @binding(2)
 var<uniform> chromatic_aberration: ChromaticAberration;
 
-@fragment
-fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
-) -> @location(0) vec4<f32> {
-    let uv = coords_to_viewport_uv(position.xy, view.viewport);
-
+fn fragment_impl(
+    position: vec4<f32>,
+    uv: vec2<f32>
+) -> vec4<f32> {
     let out = vec3<f32>(
         textureSample(texture, our_sampler, uv + (chromatic_aberration.dir_r * chromatic_aberration.magnitude_r)).r,
         textureSample(texture, our_sampler, uv + (chromatic_aberration.dir_g * chromatic_aberration.magnitude_g)).g,
@@ -36,3 +33,5 @@ fn fragment(
 
     return vec4<f32>(out, 1.0);
 }
+
+#import bevy_vfx_bag::post_processing_passthrough
diff --git a/assets/shaders/flip.wgsl b/assets/shaders/flip.wgsl
index ba264dd..be56f3d 100644
--- a/assets/shaders/flip.wgsl
+++ b/assets/shaders/flip.wgsl
@@ -14,13 +14,12 @@ struct FlipUniform {
 @group(1) @binding(2)
 var<uniform> flip: FlipUniform;
 
-@fragment
-fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
-) -> @location(0) vec4<f32> {
-    let uv_unaltered = coords_to_viewport_uv(position.xy, view.viewport);
-    let uv = abs(vec2<f32>(flip.x, flip.y) - uv_unaltered);
-
+fn fragment_impl(
+    position: vec4<f32>,
+    uv: vec2<f32>
+) -> vec4<f32> {
+    let uv = abs(vec2<f32>(flip.x, flip.y) - uv);
     return vec4<f32>(textureSample(texture, our_sampler, uv).rgb, 1.0);
 }
+
+#import bevy_vfx_bag::post_processing_passthrough
diff --git a/assets/shaders/lut.wgsl b/assets/shaders/lut.wgsl
index 92d253f..f1a1160 100644
--- a/assets/shaders/lut.wgsl
+++ b/assets/shaders/lut.wgsl
@@ -13,27 +13,32 @@ var lut: texture_3d<f32>;
 @group(1) @binding(3)
 var lut_sampler: sampler;
 
-@fragment
-fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
-) -> @location(0) vec4<f32> {
-    let uv = coords_to_viewport_uv(position.xy, view.viewport);
-
+fn fragment_impl(
+    position: vec4<f32>,
+    uv: vec2<f32>
+) -> vec4<f32> {
     // https://developer.nvidia.com/gpugems/gpugems2/part-iii-high-quality-rendering/chapter-24-using-lookup-tables-accelerate-color
     // I'm honestly not sure why this is necessary, I don't quite follow the reasoning.
     // But the neutral LUT seems indistinguishable from the original input texture
     // when this is used. Great!
     let half_texel = vec3<f32>(1.0 / 64. / 2.);
 
-    let raw_color = textureSample(texture, our_sampler, uv).rgb;
+    // Notice the ".rbg".
+    // If we sample the LUT using ".rgb" instead,
+    // the way the 3D texture is loaded will mean the
+    // green and blue colors are swapped.
+    // This mitigates that.
+    let raw_color = textureSample(texture, our_sampler, uv).rbg;
+
     var out = textureSample(lut, lut_sampler, raw_color + half_texel).rgb;
 
 #ifdef SPLIT_VERTICALLY
-    if (uv.x > 0.5) {
+    if (uv.x < 0.5) {
         out = raw_color;
     }
 #endif
 
     return vec4<f32>(out, 1.0);
 }
+
+#import bevy_vfx_bag::post_processing_passthrough
diff --git a/assets/shaders/masks.wgsl b/assets/shaders/masks.wgsl
index 2d385f3..b045033 100644
--- a/assets/shaders/masks.wgsl
+++ b/assets/shaders/masks.wgsl
@@ -76,16 +76,12 @@ fn vignette(uv: vec2<f32>) -> f32 {
 }
 #endif
 
-@fragment
-fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
-) -> @location(0) vec4<f32> {
-
-    let uv = coords_to_viewport_uv(position.xy, view.viewport);
+fn fragment_impl(
+    position: vec4<f32>,
+    uv: vec2<f32>
+) -> vec4<f32> {
     let t = textureSample(texture, our_sampler, uv);
 
-
     #ifdef SQUARE
     let mask = square(uv);
     #endif
@@ -98,3 +94,5 @@ fn fragment(
 
     return vec4<f32>(t.rgb * mask, 1.0);
 }
+
+#import bevy_vfx_bag::post_processing_passthrough
diff --git a/assets/shaders/pixelate.wgsl b/assets/shaders/pixelate.wgsl
index 5020293..5218f34 100644
--- a/assets/shaders/pixelate.wgsl
+++ b/assets/shaders/pixelate.wgsl
@@ -13,13 +13,11 @@ struct Pixelate {
 @group(1) @binding(2)
 var<uniform> pixelate: Pixelate;
 
-@fragment
-fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
-) -> @location(0) vec4<f32> {
-    var uv = coords_to_viewport_uv(position.xy, view.viewport);
-    uv += 0.5;
+fn fragment_impl(
+    position: vec4<f32>,
+    uv: vec2<f32>
+) -> vec4<f32> {
+    var uv = uv + 0.5;
 
     let width_height_over_block_size = view.viewport.zw / max(1.0, pixelate.block_size);
 
@@ -32,3 +30,5 @@ fn fragment(
 
     return vec4<f32>(textureSample(texture, our_sampler, uv).rgb, 1.0);
 }
+
+#import bevy_vfx_bag::post_processing_passthrough
diff --git a/assets/shaders/raindrops.wgsl b/assets/shaders/raindrops.wgsl
index 3f03be6..1634b45 100644
--- a/assets/shaders/raindrops.wgsl
+++ b/assets/shaders/raindrops.wgsl
@@ -32,13 +32,10 @@ fn animation(raindrops_b: f32) -> f32 {
     return fract(raindrops_b - (globals.time * raindrops.time_scaling));
 }
 
-@fragment
-fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
-) -> @location(0) vec4<f32> {
-    let uv = coords_to_viewport_uv(position.xy, view.viewport);
-
+fn fragment_impl(
+    position: vec4<f32>,
+    uv: vec2<f32>
+) -> vec4<f32> {
     // Raindrops texture wraps.
     // Make aspect-ratio independent UV coords.
     let uv_aspect_fixed = vec2<f32>(uv.x * view.viewport.z / view.viewport.w, uv.y);
@@ -65,4 +62,7 @@ fn fragment(
     let masked_norms = mask * offset;
 
     return vec4<f32>(textureSample(texture, our_sampler, uv + masked_norms).rgb, 1.0);
+
 }
+
+#import bevy_vfx_bag::post_processing_passthrough
diff --git a/assets/shaders/wave.wgsl b/assets/shaders/wave.wgsl
index ca17810..2b12423 100644
--- a/assets/shaders/wave.wgsl
+++ b/assets/shaders/wave.wgsl
@@ -21,13 +21,10 @@ struct Wave {
 @group(1) @binding(2)
 var<uniform> wave: Wave;
 
-@fragment
-fn fragment(
-    @builtin(position) position: vec4<f32>,
-    #import bevy_sprite::mesh2d_vertex_output
-) -> @location(0) vec4<f32> {
-    let uv = coords_to_viewport_uv(position.xy, view.viewport);
-
+fn fragment_impl(
+    position: vec4<f32>,
+    uv: vec2<f32>
+) -> vec4<f32> {
     let pi_uv = PI * uv;
     let pi_time = PI * globals.time;
 
@@ -37,4 +34,7 @@ fn fragment(
     let uv_displaced = vec2<f32>(uv.x + offset_x, uv.y + offset_y);
 
     return vec4<f32>(textureSample(texture, our_sampler, uv_displaced).rgb, 1.0);
+
 }
+
+#import bevy_vfx_bag::post_processing_passthrough
diff --git a/examples/examples_common.rs b/examples/examples_common.rs
index 5b085b3..98a2bb2 100644
--- a/examples/examples_common.rs
+++ b/examples/examples_common.rs
@@ -20,13 +20,16 @@ impl Default for ExampleText {
 
 impl Plugin for SaneDefaultsPlugin {
     fn build(&self, app: &mut App) {
-        app.insert_resource(AssetServerSettings {
-            watch_for_changes: true,
-            ..default()
-        })
-        .init_resource::<ExampleText>()
-        .add_plugins(DefaultPlugins)
-        .add_system(bevy::window::close_on_esc);
+        app.init_resource::<ExampleText>()
+            .add_plugins(
+                DefaultPlugins
+                    .set(AssetPlugin {
+                        watch_for_changes: true,
+                        ..default()
+                    })
+                    .set(ImagePlugin::default_nearest()),
+            )
+            .add_system(bevy::window::close_on_esc);
     }
 }
 
@@ -60,8 +63,7 @@ pub(crate) struct ShouldAdd3dCameraBundle(bool);
 
 impl Plugin for ShapesExamplePlugin {
     fn build(&self, app: &mut App) {
-        app.insert_resource(ImageSettings::default_nearest())
-            .insert_resource(ShouldAdd3dCameraBundle(self.add_3d_camera_bundle))
+        app.insert_resource(ShouldAdd3dCameraBundle(self.add_3d_camera_bundle))
             .add_plugin(FrameTimeDiagnosticsPlugin::default())
             .add_startup_system(shapes::setup)
             .add_startup_system(ui::setup)
@@ -223,7 +225,7 @@ mod ui {
                     "hello\nbevy!",
                     TextStyle {
                         font: asset_server.load("fonts/FiraSans-Bold.ttf"),
-                        font_size: 40.0,
+                        font_size: 30.0,
                         color: Color::WHITE,
                     },
                 ) // Set the alignment of the Text
diff --git a/examples/lut/main.rs b/examples/lut/main.rs
index ed4d829..0b38051 100644
--- a/examples/lut/main.rs
+++ b/examples/lut/main.rs
@@ -1,23 +1,13 @@
 #[path = "../examples_common.rs"]
 mod examples_common;
 
-use bevy::{prelude::*, utils::HashMap};
+use bevy::prelude::*;
 
 use bevy_vfx_bag::{
-    image::lut::{Lut, Lut3d, LutPlugin},
+    image::lut::{Lut, LutPassthrough, LutPlugin, Luts},
     BevyVfxBagPlugin, PostProcessingInput,
 };
 
-// Load the LUT presets from disk via the asset server,
-// and give them a readable name.
-// When the event fires that the image is actually loaded,
-// move it into the vector of LUTs ready for use.
-#[derive(Debug, Resource, Default)]
-struct LutsState {
-    handles: HashMap<Handle<Image>, &'static str>,
-    ready: Vec<(&'static str, Lut3d)>,
-}
-
 fn main() {
     let mut app = App::new();
 
@@ -25,14 +15,12 @@ fn main() {
         .add_plugin(examples_common::ShapesExamplePlugin::without_3d_camera())
         .add_plugin(BevyVfxBagPlugin)
         .add_plugin(LutPlugin)
-        .init_resource::<LutsState>()
         .add_startup_system(startup)
-        .add_system(make_luts)
         .add_system(update)
         .run();
 }
 
-fn startup(mut commands: Commands, assets: Res<AssetServer>, mut luts: ResMut<LutsState>) {
+fn startup(mut commands: Commands) {
     commands
         .spawn(Camera3dBundle {
             transform: Transform::from_xyz(0.0, 6., 12.0)
@@ -40,60 +28,41 @@ fn startup(mut commands: Commands, assets: Res<AssetServer>, mut luts: ResMut<Lu
             ..default()
         })
         .insert(PostProcessingInput);
-
-    *luts = LutsState {
-        handles: HashMap::from_iter(vec![
-            (assets.load("luts/neutral.png"), "Neutral"),
-            (assets.load("luts/burlesque.png"), "Burlesque"),
-            (assets.load("luts/neo.png"), "Neo"),
-            (assets.load("luts/rouge.png"), "Rouge"),
-            (assets.load("luts/sauna.png"), "Sauna"),
-            (assets.load("luts/slate.png"), "Slate"),
-            (assets.load("luts/arctic.png"), "Arctic"),
-            (assets.load("luts/denim.png"), "Denim"),
-        ]),
-        ready: vec![],
-    };
-}
-
-// Move loaded LUT images into the "ready" state by
-// creating them as 3D LUTs.
-fn make_luts(
-    mut ev_asset: EventReader<AssetEvent<Image>>,
-    mut assets: ResMut<Assets<Image>>,
-    mut luts: ResMut<LutsState>,
-) {
-    for ev in ev_asset.iter() {
-        if let AssetEvent::Created { handle } = ev {
-            if let Some(lut_name) = luts.handles.remove(handle) {
-                luts.ready
-                    .push((lut_name, Lut3d::from_image(&mut assets, handle)));
-            }
-        }
-    }
 }
 
 // Cycle through some preset LUTs.
 fn update(
-    time: Res<Time>,
     mut choice: Local<usize>,
     mut lut: ResMut<Lut>,
+    luts: Res<Luts>,
     mut text: ResMut<examples_common::ExampleText>,
-    luts_state: Res<LutsState>,
     keyboard_input: Res<Input<KeyCode>>,
+    mut passthrough: ResMut<LutPassthrough>,
 ) {
-    let num_luts = luts_state.ready.len();
+    let luts = luts.ready.iter().collect::<Vec<_>>();
+
+    let num_luts = luts.len();
     if num_luts == 0 {
         return;
     }
 
+    if keyboard_input.just_pressed(KeyCode::P) {
+        passthrough.0 = !passthrough.0;
+    }
+
     if keyboard_input.just_pressed(KeyCode::S) {
         lut.split_vertically = !lut.split_vertically;
     }
 
-    let choice_now = time.elapsed_seconds() as usize % num_luts;
+    let choice_now = if keyboard_input.just_pressed(KeyCode::Left) {
+        choice.saturating_sub(1)
+    } else if keyboard_input.just_pressed(KeyCode::Right) {
+        (*choice + 1).min(num_luts - 1)
+    } else {
+        *choice
+    };
 
-    let (name, lut3d) = &luts_state.ready[choice_now];
+    let (name, lut3d) = &luts[choice_now];
 
     if *choice != choice_now {
         *choice = choice_now;
@@ -101,8 +70,9 @@ fn update(
     }
 
     text.0 = format!(
-        "LUT {}/{num_luts}: {name}, [S]plit: {:?}",
+        "(←→) LUT {}/{num_luts}: {name}, [S]plit: {:?}, [P]assthrough: {:?}",
         *choice + 1,
         lut.split_vertically,
+        passthrough.0
     );
 }
diff --git a/examples/pixelate/main.rs b/examples/pixelate/main.rs
index b5a794f..217cbb9 100644
--- a/examples/pixelate/main.rs
+++ b/examples/pixelate/main.rs
@@ -4,7 +4,7 @@ mod examples_common;
 use bevy::prelude::*;
 
 use bevy_vfx_bag::{
-    image::pixelate::{Pixelate, PixelatePlugin},
+    image::pixelate::{Pixelate, PixelatePassthrough, PixelatePlugin},
     BevyVfxBagPlugin, PostProcessingInput,
 };
 
@@ -33,10 +33,15 @@ fn startup(mut commands: Commands) {
 fn update(
     keyboard_input: Res<Input<KeyCode>>,
     mut pixelate: ResMut<Pixelate>,
+    mut passthrough: ResMut<PixelatePassthrough>,
     mut text: ResMut<examples_common::ExampleText>,
 ) {
     let mut pixelate_diff = 0.0;
 
+    if keyboard_input.just_pressed(KeyCode::P) {
+        passthrough.0 = !passthrough.0;
+    }
+
     if keyboard_input.just_pressed(KeyCode::Up) {
         pixelate_diff = 1.0;
     } else if keyboard_input.just_pressed(KeyCode::Down) {
@@ -46,5 +51,8 @@ fn update(
     pixelate.block_size += pixelate_diff;
     pixelate.block_size = 1.0_f32.max(pixelate.block_size);
 
-    text.0 = format!("Pixelate block size (↑↓): {:.2?}", pixelate.block_size);
+    text.0 = format!(
+        "Pixelate block size (↑↓): {:.2?}, [P]assthrough: {:?}",
+        pixelate.block_size, passthrough.0
+    );
 }
diff --git a/examples/raindrops/main.rs b/examples/raindrops/main.rs
index 708f3fc..4b387b5 100644
--- a/examples/raindrops/main.rs
+++ b/examples/raindrops/main.rs
@@ -4,7 +4,7 @@ mod examples_common;
 use bevy::{input::mouse::MouseWheel, prelude::*};
 
 use bevy_vfx_bag::{
-    image::rainrops::{Raindrops, RaindropsPlugin},
+    image::raindrops::{Raindrops, RaindropsPassthrough, RaindropsPlugin},
     BevyVfxBagPlugin, PostProcessingInput,
 };
 
@@ -35,6 +35,7 @@ fn update(
     mut mouse_wheel_events: EventReader<MouseWheel>,
     mut raindrops: ResMut<Raindrops>,
     mut text: ResMut<examples_common::ExampleText>,
+    mut passthrough: ResMut<RaindropsPassthrough>,
 ) {
     let mut time_scaling_diff = 0.0;
     let mut intensity_diff = 0.0;
@@ -60,13 +61,17 @@ fn update(
         }
     }
 
+    if keyboard_input.just_pressed(KeyCode::P) {
+        passthrough.0 = !passthrough.0;
+    }
+
     raindrops.time_scaling += time_scaling_diff;
     raindrops.intensity += intensity_diff;
     raindrops.zoom += zoom_diff;
 
     // Display parameters on screen
     text.0 = format!(
-        "(Press ←↑→↓, MouseWheel) Time scaling: {:.2?}, intensity: {:.2?}, zoom: {:.2?}",
-        raindrops.time_scaling, raindrops.intensity, raindrops.zoom
+        "(Press ←↑→↓, MouseWheel) Time scaling: {:.2?}, intensity: {:.2?}, zoom: {:.2?}, [p]assthrough: {:?}",
+        raindrops.time_scaling, raindrops.intensity, raindrops.zoom, passthrough.0
     );
 }
diff --git a/examples/trex/main.rs b/examples/trex/main.rs
new file mode 100644
index 0000000..14c721b
--- /dev/null
+++ b/examples/trex/main.rs
@@ -0,0 +1,59 @@
+#[path = "../examples_common.rs"]
+mod examples_common;
+
+use bevy::prelude::*;
+
+use bevy_vfx_bag::{
+    image::wave::{Wave, WavePassthrough, WavePlugin},
+    BevyVfxBagPlugin, PostProcessingInput,
+};
+
+#[derive(Debug, Resource, Default)]
+struct SlowerTime(Time);
+
+fn main() {
+    App::new()
+        .add_plugin(examples_common::SaneDefaultsPlugin)
+        .add_plugin(examples_common::ShapesExamplePlugin::without_3d_camera())
+        .add_plugin(BevyVfxBagPlugin)
+        .insert_resource(Wave {
+            waves_x: 2.0,
+            waves_y: 0.1,
+            speed_x: 30.,
+            speed_y: 20.,
+            amplitude_x: 0.01,
+            amplitude_y: 0.01,
+        })
+        .add_plugin(WavePlugin)
+        .add_startup_system(startup)
+        .add_system(update)
+        .run();
+}
+
+fn startup(mut commands: Commands) {
+    commands
+        .spawn(Camera3dBundle {
+            transform: Transform::from_xyz(0.0, 6., 12.0)
+                .looking_at(Vec3::new(0., 1., 0.), Vec3::Y),
+            ..default()
+        })
+        .insert(PostProcessingInput);
+}
+
+fn update(
+    time: Res<Time>,
+    mut earthquake_passthrough: ResMut<WavePassthrough>,
+    mut text: ResMut<examples_common::ExampleText>,
+) {
+    let fract = time.elapsed_seconds().fract();
+
+    let relax = fract < 0.8;
+
+    if relax {
+        text.0 = "Is that a T-Rex approaching?!".into();
+    } else {
+        text.0 = "<GROUND SHAKE>".into();
+    }
+
+    earthquake_passthrough.0 = relax;
+}
diff --git a/examples/underwater/main.rs b/examples/underwater/main.rs
index 506af0c..36defbc 100644
--- a/examples/underwater/main.rs
+++ b/examples/underwater/main.rs
@@ -9,7 +9,7 @@ use bevy_vfx_bag::{
         flip::{Flip, FlipPlugin},
         lut::{Lut, Lut3d, LutPlugin},
         mask::{Mask, MaskPlugin},
-        rainrops::RaindropsPlugin,
+        raindrops::RaindropsPlugin,
         wave::{Wave, WavePlugin},
     },
     BevyVfxBagPlugin, PostProcessingInput,
diff --git a/src/image.rs b/src/image.rs
index c035d41..435ce47 100644
--- a/src/image.rs
+++ b/src/image.rs
@@ -8,7 +8,7 @@ pub mod flip;
 pub mod blur;
 
 /// A raindrops effect.
-pub mod rainrops;
+pub mod raindrops;
 
 /// A wave effect.
 pub mod wave;
diff --git a/src/image/blur.rs b/src/image/blur.rs
index 1f63368..519eeed 100644
--- a/src/image/blur.rs
+++ b/src/image/blur.rs
@@ -1,13 +1,19 @@
 use bevy::{
     prelude::*,
     reflect::TypeUuid,
-    render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
-    sprite::{Material2d, Material2dPlugin},
+    render::{
+        mesh::MeshVertexBufferLayout,
+        render_resource::{
+            AsBindGroup, RenderPipelineDescriptor, ShaderRef, ShaderType,
+            SpecializedMeshPipelineError,
+        },
+    },
+    sprite::{Material2d, Material2dKey, Material2dPlugin},
 };
 
 use crate::{
-    load_asset_if_no_dev_feature, new_effect_state, setup_effect, shader_ref, EffectState,
-    HasEffectState,
+    load_asset_if_no_dev_feature, new_effect_state, passthrough, setup_effect, shader_ref,
+    EffectState, HasEffectState, Passthrough,
 };
 
 const BLUR_SHADER_HANDLE: HandleUntyped =
@@ -40,8 +46,26 @@ impl Default for Blur {
     }
 }
 
+/// If this effect should not be enabled, i.e. it should just
+/// pass through the input image.
+#[derive(Debug, Resource, Default, PartialEq, Eq, Hash, Clone)]
+pub struct BlurPassthrough(pub bool);
+
+impl Passthrough for BlurPassthrough {
+    fn passthrough(&self) -> bool {
+        self.0
+    }
+}
+
+impl From<&BlurMaterial> for BlurPassthrough {
+    fn from(material: &BlurMaterial) -> Self {
+        Self(material.passthrough)
+    }
+}
+
 #[derive(Debug, AsBindGroup, TypeUuid, Clone, Resource)]
 #[uuid = "1b35a535-d428-4822-aba5-15e104ea80b5"]
+#[bind_group_data(BlurPassthrough)]
 struct BlurMaterial {
     #[texture(0)]
     #[sampler(1)]
@@ -51,12 +75,24 @@ struct BlurMaterial {
     blur: Blur,
 
     state: EffectState,
+
+    passthrough: bool,
 }
 
 impl Material2d for BlurMaterial {
     fn fragment_shader() -> ShaderRef {
         shader_ref!(BLUR_SHADER_HANDLE, "shaders/blur.wgsl")
     }
+
+    fn specialize(
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &MeshVertexBufferLayout,
+        key: Material2dKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        passthrough(descriptor, &key);
+
+        Ok(())
+    }
 }
 
 impl HasEffectState for BlurMaterial {
@@ -74,17 +110,23 @@ impl FromWorld for BlurMaterial {
             source_image: state.input_image_handle.clone_weak(),
             blur: *blur,
             state,
+            passthrough: false,
         }
     }
 }
 
-fn update_blur(mut blur_materials: ResMut<Assets<BlurMaterial>>, blur: Res<Blur>) {
-    if !blur.is_changed() {
+fn update_blur(
+    mut blur_materials: ResMut<Assets<BlurMaterial>>,
+    blur: Res<Blur>,
+    passthrough: Res<BlurPassthrough>,
+) {
+    if !blur.is_changed() && !passthrough.is_changed() {
         return;
     }
 
     for (_, material) in blur_materials.iter_mut() {
         material.blur = *blur;
+        material.passthrough = passthrough.0;
     }
 }
 
@@ -96,6 +138,7 @@ impl Plugin for BlurPlugin {
 
         app.init_resource::<Blur>()
             .init_resource::<BlurMaterial>()
+            .init_resource::<BlurPassthrough>()
             .add_plugin(Material2dPlugin::<BlurMaterial>::default())
             .add_startup_system(setup_effect::<BlurMaterial>)
             .add_system(update_blur);
diff --git a/src/image/chromatic_aberration.rs b/src/image/chromatic_aberration.rs
index 504c373..19f4482 100644
--- a/src/image/chromatic_aberration.rs
+++ b/src/image/chromatic_aberration.rs
@@ -3,13 +3,19 @@ use std::f32::consts::PI;
 use bevy::{
     prelude::*,
     reflect::TypeUuid,
-    render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
-    sprite::{Material2d, Material2dPlugin},
+    render::{
+        mesh::MeshVertexBufferLayout,
+        render_resource::{
+            AsBindGroup, RenderPipelineDescriptor, ShaderRef, ShaderType,
+            SpecializedMeshPipelineError,
+        },
+    },
+    sprite::{Material2d, Material2dKey, Material2dPlugin},
 };
 
 use crate::{
-    load_asset_if_no_dev_feature, new_effect_state, setup_effect, shader_ref, EffectState,
-    HasEffectState,
+    load_asset_if_no_dev_feature, new_effect_state, passthrough, setup_effect, shader_ref,
+    EffectState, HasEffectState, Passthrough,
 };
 
 const CHROMATIC_ABERRATION_SHADER_HANDLE: HandleUntyped =
@@ -60,8 +66,26 @@ impl Default for ChromaticAberration {
     }
 }
 
+/// If this effect should not be enabled, i.e. it should just
+/// pass through the input image.
+#[derive(Debug, Resource, Default, PartialEq, Eq, Hash, Clone)]
+pub struct ChromaticAberrationPassthrough(pub bool);
+
+impl Passthrough for ChromaticAberrationPassthrough {
+    fn passthrough(&self) -> bool {
+        self.0
+    }
+}
+
+impl From<&ChromaticAberrationMaterial> for ChromaticAberrationPassthrough {
+    fn from(material: &ChromaticAberrationMaterial) -> Self {
+        Self(material.passthrough)
+    }
+}
+
 #[derive(Debug, AsBindGroup, TypeUuid, Clone, Resource)]
 #[uuid = "1c857de0-74e6-42a4-a1b4-0e0f1564a880"]
+#[bind_group_data(ChromaticAberrationPassthrough)]
 struct ChromaticAberrationMaterial {
     #[texture(0)]
     #[sampler(1)]
@@ -71,6 +95,8 @@ struct ChromaticAberrationMaterial {
     chromatic_aberration: ChromaticAberration,
 
     state: EffectState,
+
+    passthrough: bool,
 }
 
 impl HasEffectState for ChromaticAberrationMaterial {
@@ -83,9 +109,19 @@ impl Material2d for ChromaticAberrationMaterial {
     fn fragment_shader() -> ShaderRef {
         shader_ref!(
             CHROMATIC_ABERRATION_SHADER_HANDLE,
-            "shaders/chromatic_aberration.wgsl"
+            "shaders/chromatic-aberration.wgsl"
         )
     }
+
+    fn specialize(
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &MeshVertexBufferLayout,
+        key: Material2dKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        passthrough(descriptor, &key);
+
+        Ok(())
+    }
 }
 
 impl FromWorld for ChromaticAberrationMaterial {
@@ -99,6 +135,7 @@ impl FromWorld for ChromaticAberrationMaterial {
             source_image: state.input_image_handle.clone_weak(),
             chromatic_aberration: *ca,
             state,
+            passthrough: false,
         }
     }
 }
@@ -106,8 +143,10 @@ impl FromWorld for ChromaticAberrationMaterial {
 fn update_chromatic_aberration(
     mut chromatic_aberration_materials: ResMut<Assets<ChromaticAberrationMaterial>>,
     chromatic_aberration: Res<ChromaticAberration>,
+
+    passthrough: Res<ChromaticAberrationPassthrough>,
 ) {
-    if !chromatic_aberration.is_changed() {
+    if !chromatic_aberration.is_changed() && !passthrough.is_changed() {
         return;
     }
 
@@ -119,6 +158,7 @@ fn update_chromatic_aberration(
 
     for (_, material) in chromatic_aberration_materials.iter_mut() {
         material.chromatic_aberration = ca;
+        material.passthrough = passthrough.0;
     }
 }
 
@@ -134,6 +174,7 @@ impl Plugin for ChromaticAberrationPlugin {
 
         app.init_resource::<ChromaticAberration>()
             .init_resource::<ChromaticAberrationMaterial>()
+            .init_resource::<ChromaticAberrationPassthrough>()
             .add_plugin(Material2dPlugin::<ChromaticAberrationMaterial>::default())
             .add_startup_system(setup_effect::<ChromaticAberrationMaterial>)
             .add_system(update_chromatic_aberration);
diff --git a/src/image/flip.rs b/src/image/flip.rs
index 4457026..34dbc7a 100644
--- a/src/image/flip.rs
+++ b/src/image/flip.rs
@@ -1,13 +1,19 @@
 use bevy::{
     prelude::*,
     reflect::TypeUuid,
-    render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
-    sprite::{Material2d, Material2dPlugin},
+    render::{
+        mesh::MeshVertexBufferLayout,
+        render_resource::{
+            AsBindGroup, RenderPipelineDescriptor, ShaderRef, ShaderType,
+            SpecializedMeshPipelineError,
+        },
+    },
+    sprite::{Material2d, Material2dKey, Material2dPlugin},
 };
 
 use crate::{
-    load_asset_if_no_dev_feature, new_effect_state, setup_effect, shader_ref, EffectState,
-    HasEffectState,
+    load_asset_if_no_dev_feature, new_effect_state, passthrough, setup_effect, shader_ref,
+    EffectState, HasEffectState, Passthrough,
 };
 
 const FLIP_SHADER_HANDLE: HandleUntyped =
@@ -53,8 +59,26 @@ struct FlipUniform {
     y: f32,
 }
 
+/// If this effect should not be enabled, i.e. it should just
+/// pass through the input image.
+#[derive(Debug, Resource, Default, PartialEq, Eq, Hash, Clone)]
+pub struct FlipPassthrough(pub bool);
+
+impl Passthrough for FlipPassthrough {
+    fn passthrough(&self) -> bool {
+        self.0
+    }
+}
+
+impl From<&FlipMaterial> for FlipPassthrough {
+    fn from(material: &FlipMaterial) -> Self {
+        Self(material.passthrough)
+    }
+}
+
 #[derive(Debug, AsBindGroup, TypeUuid, Clone, Resource)]
 #[uuid = "70bc3d3b-46e2-40ea-bedc-e0d73ffdd3fd"]
+#[bind_group_data(FlipPassthrough)]
 struct FlipMaterial {
     #[texture(0)]
     #[sampler(1)]
@@ -64,6 +88,8 @@ struct FlipMaterial {
     flip: FlipUniform,
 
     state: EffectState,
+
+    passthrough: bool,
 }
 
 impl HasEffectState for FlipMaterial {
@@ -76,6 +102,16 @@ impl Material2d for FlipMaterial {
     fn fragment_shader() -> ShaderRef {
         shader_ref!(FLIP_SHADER_HANDLE, "shaders/flip.wgsl")
     }
+
+    fn specialize(
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &MeshVertexBufferLayout,
+        key: Material2dKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        passthrough(descriptor, &key);
+
+        Ok(())
+    }
 }
 
 impl FromWorld for FlipMaterial {
@@ -87,6 +123,7 @@ impl FromWorld for FlipMaterial {
             source_image: state.input_image_handle.clone_weak(),
             flip: FlipUniform::from(*flip),
             state,
+            passthrough: false,
         }
     }
 }
@@ -109,6 +146,7 @@ impl Plugin for FlipPlugin {
 
         app.init_resource::<Flip>()
             .init_resource::<FlipMaterial>()
+            .init_resource::<FlipPassthrough>()
             .add_plugin(Material2dPlugin::<FlipMaterial>::default())
             .add_startup_system(setup_effect::<FlipMaterial>)
             .add_system(update_flip);
diff --git a/src/image/lut/mod.rs b/src/image/lut/mod.rs
index 2452ddb..3377dc3 100644
--- a/src/image/lut/mod.rs
+++ b/src/image/lut/mod.rs
@@ -24,13 +24,15 @@ use bevy::{
             SpecializedMeshPipelineError, TextureDimension, TextureFormat, TextureViewDescriptor,
             TextureViewDimension,
         },
-        texture::{CompressedImageFormats, ImageType},
+        texture::{CompressedImageFormats, ImageSampler, ImageType},
     },
     sprite::{Material2d, Material2dKey, Material2dPlugin},
+    utils::HashMap,
 };
 
 use crate::{
-    load_asset_if_no_dev_feature, new_effect_state, setup_effect, EffectState, HasEffectState,
+    load_asset_if_no_dev_feature, new_effect_state, passthrough, setup_effect, EffectState,
+    HasEffectState, Passthrough,
 };
 
 const LUT_SHADER_HANDLE: HandleUntyped =
@@ -119,6 +121,8 @@ impl Lut3d {
             ..default()
         });
 
+        image.sampler_descriptor = ImageSampler::linear();
+
         let handle = images.add(image);
 
         Self(handle)
@@ -143,22 +147,6 @@ impl Lut3d {
     }
 }
 
-/// The neutral LUT.
-#[derive(Debug, Clone, Resource)]
-pub struct LutNeutral(Lut3d);
-
-impl FromWorld for LutNeutral {
-    fn from_world(world: &mut World) -> Self {
-        let mut images = world
-            .get_resource_mut::<Assets<Image>>()
-            .expect("Assets<Image> should exist");
-
-        let data = include_bytes!("neutral.png");
-
-        Self(Lut3d::new(&mut *images, data))
-    }
-}
-
 impl<'a> From<&'a Lut> for Option<&'a Handle<Image>> {
     fn from(lut: &'a Lut) -> Self {
         Some(&lut.texture.0)
@@ -178,6 +166,8 @@ struct LutMaterial {
     lut: Lut,
 
     state: EffectState,
+
+    passthrough: bool,
 }
 
 impl HasEffectState for LutMaterial {
@@ -200,6 +190,8 @@ impl Material2d for LutMaterial {
         _layout: &MeshVertexBufferLayout,
         key: Material2dKey<Self>,
     ) -> Result<(), SpecializedMeshPipelineError> {
+        passthrough(descriptor, &key);
+
         let mut push_def = |def: &str| {
             descriptor
                 .fragment
@@ -226,6 +218,7 @@ impl FromWorld for LutMaterial {
             source_image: state.input_image_handle.clone_weak(),
             state,
             lut: lut.clone(),
+            passthrough: false,
         }
     }
 }
@@ -233,23 +226,165 @@ impl FromWorld for LutMaterial {
 #[derive(Eq, PartialEq, Hash, Clone)]
 struct LutMaterialKey {
     split_vertically: bool,
+    passthrough: bool,
+}
+
+impl Passthrough for LutMaterialKey {
+    fn passthrough(&self) -> bool {
+        self.passthrough
+    }
+}
+
+/// If this effect should not be enabled, i.e. it should just
+/// pass through the input image.
+#[derive(Debug, Resource, Default, PartialEq, Eq, Hash, Clone)]
+pub struct LutPassthrough(pub bool);
+
+impl Passthrough for LutPassthrough {
+    fn passthrough(&self) -> bool {
+        self.0
+    }
 }
 
 impl From<&LutMaterial> for LutMaterialKey {
     fn from(lut_material: &LutMaterial) -> Self {
         Self {
             split_vertically: lut_material.lut.split_vertically,
+            passthrough: lut_material.passthrough,
         }
     }
 }
 
-fn update_lut(mut lut_materials: ResMut<Assets<LutMaterial>>, lut: Res<Lut>) {
-    if !lut.is_changed() {
+fn update_lut(
+    mut lut_materials: ResMut<Assets<LutMaterial>>,
+    lut: Res<Lut>,
+    passthrough: Res<LutPassthrough>,
+) {
+    if !lut.is_changed() && !passthrough.is_changed() {
         return;
     }
 
     for (_, material) in lut_materials.iter_mut() {
-        material.lut = lut.clone()
+        material.lut = lut.clone();
+        material.passthrough = passthrough.0;
+    }
+}
+
+/// LUTs available for use.
+///
+/// They can be used by calling `.set_texture` on [`Lut`].
+///
+/// By loading a new image and inserting it into the handles in this resource,
+/// the image will automatically be transformed into a [`Lut3d`] when loaded
+/// and moved into the `ready` field.
+///
+/// The LUTs shipped with the plugin itself (applied using `.set_texture`) are:
+///     - "Neutral"
+///     - "Arctic"
+///     - "Burlesque"
+///     - "Denim"
+///     - "Neo"
+///     - "Rouge"
+///     - "Sauna"
+///     - "Slate"
+#[derive(Debug, Resource)]
+pub struct Luts {
+    /// Handles to images which have not yet been loaded
+    /// and moved into `ready`.
+    pub handles: HashMap<Handle<Image>, &'static str>,
+
+    /// [`Lut3d`]s which are ready for use.
+    /// See [`Lut::set_texture`].
+    pub ready: HashMap<&'static str, Lut3d>,
+}
+
+impl FromWorld for Luts {
+    #[cfg(feature = "dev")]
+    fn from_world(world: &mut World) -> Self {
+        let assets = world.resource::<AssetServer>();
+
+        Self {
+            handles: HashMap::from_iter(vec![
+                (assets.load("luts/neutral.png"), "Neutral"),
+                (assets.load("luts/arctic.png"), "Arctic"),
+                (assets.load("luts/burlesque.png"), "Burlesque"),
+                (assets.load("luts/denim.png"), "Denim"),
+                (assets.load("luts/neo.png"), "Neo"),
+                (assets.load("luts/rouge.png"), "Rouge"),
+                (assets.load("luts/sauna.png"), "Sauna"),
+                (assets.load("luts/slate.png"), "Slate"),
+            ]),
+            ready: HashMap::new(),
+        }
+    }
+
+    #[cfg(not(feature = "dev"))]
+    fn from_world(world: &mut World) -> Self {
+        let mut assets = world.resource_mut::<Assets<Image>>();
+
+        macro_rules! load {
+            ($assets: ident, $name: literal, $image_path: literal) => {
+                (
+                    $assets.add(
+                        Image::from_buffer(
+                            include_bytes!($image_path),
+                            ImageType::Extension("png"), // todo
+                            CompressedImageFormats::NONE,
+                            // If `true` the output the mapping is very dark.
+                            // If not, it's much closer to the original.
+                            false,
+                        )
+                        .expect("Should be able to load image from buffer"),
+                    ),
+                    $name,
+                )
+            };
+        }
+
+        Self {
+            handles: HashMap::from_iter(vec![
+                load!(assets, "Neutral", "../../../assets/luts/neutral.png"),
+                load!(assets, "Arctic", "../../../assets/luts/arctic.png"),
+                load!(assets, "Burlesque", "../../../assets/luts/burlesque.png"),
+                load!(assets, "Denim", "../../../assets/luts/denim.png"),
+                load!(assets, "Neo", "../../../assets/luts/neo.png"),
+                load!(assets, "Rouge", "../../../assets/luts/rouge.png"),
+                load!(assets, "Sauna", "../../../assets/luts/sauna.png"),
+                load!(assets, "Slate", "../../../assets/luts/slate.png"),
+            ]),
+            ready: HashMap::new(),
+        }
+    }
+}
+
+fn add_created_3d_luts(
+    mut ev_asset: EventReader<AssetEvent<Image>>,
+    mut assets: ResMut<Assets<Image>>,
+    mut luts: ResMut<Luts>,
+) {
+    for ev in ev_asset.iter() {
+        if let AssetEvent::Created { handle } = ev {
+            if let Some(lut_name) = luts.handles.remove(handle) {
+                luts.ready
+                    .insert(lut_name, Lut3d::from_image(&mut assets, handle));
+            }
+        }
+    }
+}
+
+/// The neutral LUT.
+#[derive(Debug, Clone, Resource)]
+pub struct LutNeutral(Lut3d);
+
+impl FromWorld for LutNeutral {
+    fn from_world(world: &mut World) -> Self {
+        let mut images = world
+            .get_resource_mut::<Assets<Image>>()
+            .expect("Assets<Image> should exist");
+
+        let data = include_bytes!("../../../assets/luts/neutral.png");
+
+        Self(Lut3d::new(&mut *images, data))
     }
 }
 
@@ -260,14 +395,17 @@ impl Plugin for LutPlugin {
         load_asset_if_no_dev_feature!(app, LUT_SHADER_HANDLE, "../../../assets/shaders/lut.wgsl");
 
         app
-            // Initialize the fallback neutral LUT in case the user
-            // has not initialized [`Lut`]
+            // Custom LUTs
+            .init_resource::<Luts>()
+            // The "no-op" LUT
             .init_resource::<LutNeutral>()
-            // Now initialize [`Lut`], which will then use [`LutNeutral`] if it must.
+            // The user config
             .init_resource::<Lut>()
             .init_resource::<LutMaterial>()
+            .init_resource::<LutPassthrough>()
             .add_plugin(Material2dPlugin::<LutMaterial>::default())
             .add_startup_system(setup_effect::<LutMaterial>)
+            .add_system(add_created_3d_luts)
             .add_system(update_lut);
     }
 }
diff --git a/src/image/lut/neutral.png b/src/image/lut/neutral.png
deleted file mode 100644
index 00c50ab247d6344cf590c283b460727d5ad730a0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4328
zcma)AYfuwc7~QM{C5px%>Yzg86)H4Rg#lE^N})VOiilLP*jj;6l!qOGfRZTMVx=;U
zqmETcXX-GDZq{nmN)=jP?Q{^P0@bPoR0fpML@-zgVf)2L%e`4=?w`!g&7M8qIp4YW
z+oU`(A<9wWBB3bCF(x`9iK3)%Nikz+_;il)x(^Hbn23eRg`y{SzDl^mNX3aBAw2)P
z<D$56(^S_|WQNY<fWV&j=D%ofipUDv@yS$QxBaotOunkx;nh?1wb^{(CRK}G&vzPD
zwwzwxSj8vTTjsW8?XC%HWM2%euZz0rJiMf$|CZ(E!T4o&Rd9KpH+TK9V|i*(za`N!
zXfYS_-#;IJMy*QjDIKt!HpbT-KCVvb8E8Ay<yv#3MLoQ+_nhf?<_|~shN7pZ9)EPQ
zOQk4Xp&xO};O?J$O7$uOZ8Bds@2~yX?8m~ls-fX^&w}<WZCo45_aCWZlS6AvL)Cvh
zdA2jN@9weIzMO_?-<Mw=+f<xpI??*VU@+DFnNy%`E8vUyeEz9<;L&i7LHj7SrR%oI
z!t*^{yQ@?M+Q)rYEh@{SX4hr#z{BSBoS$lLw@(n!c4MS+Mnk>2kow78u%*h`@|iYE
z#t=S-Y7Z)@TI2a27A~}He)9P?Hw)l%7X^>Er`T~}Bgq*J!)iW5>Vc(8nlhWE`pocA
zRFz~{_J8G8_B7FN=<_ITiO9iWgg)zCCE7X%M`~z|ab)FCbdva?JGRs-_C)l-UA^KB
zfWA9@0mdCKI!44@YUSQ$#Eg%gR9XJI1#e3DbxLKW&C)+rO;mlU1CNm}5S0^=>&xt^
zOFq*vLjpuaMCf8Ly<lt<+6{Re<AP?0k*71^HcPAaK;?Fqu_#5$D!1E+6wrOZJAm?U
z$&G)L(^n?t+j-7>W7q2>2zKm}R{&+KxU9e`k7UN%lqpboyH$5vXvqgC`5e3Nko3LG
zhCp1lcmnyTE7chJLdKqmJoA^l^FwL9A=s{J`cczw6KtWZdv^ryYB(syxOD484Nh43
z1GEf{m53go*Ms(x<<2O)>73>%5&38c`vT@v1nQi6aud-ZVf6V{q=}l<iiVS^qvt6|
zy6y^@F;-r6N1f|l%Cw=ac*_y<0QQP&ZK@YawOP`AkSMS*S=1`~YjZI251B?H@-(o0
z<D6F1WTup!=Z%&F$B{tfGMrqf14r|=qJ=*9)}^C;e9KM^1KW$HWn#9c(-$x=gvlq%
zT&UFgyqy@ir*0V$`8z=FHKPk7SJCsx$U%AP!@NBhxw~#L5qSuZuW`%7Y<HtC*iHcf
z+f%H{Mfq4hp38MnMC9*w1gEve9>TMopwxvD;R9i(*91yX=P2!xu~}cEc1Q(BOX^}s
z?7e6)n%H32>i81{XR0G?^=u|79Np?S{B%J?#m7P5SL|)ZCR3lJdlyOVxAwwt@%D~H
z_g4D}dXQ+MpN09rHN-e$(yKKrk@O0y^s*#uKHTupDTt)6vr0eOJP|pLwS5lVUlK__
z1ky8RZO5c%(}P5#@vH)*-;4Far0>^kAd(&qwTu0ZV&w6(nuvTB7?*se8J#-XzA@cp
zB+7lDYl-)huy=wR?z#yiw(IsaQA|TzASV0^jgm<CryxAizY`Naj#eXGgog_r(8nFF
zcO+em2t~=|#thLNqN&_j_P~FiK2L<>Q$*ho;Y~2x9%ryvtp;a~XfAUea7@m~Qer(e
zOyYvDf&_m%a0-Bju4Qq!6E~L#?hEjh*-C6@8)V#UBKT~8Z{EP-@QIu+5qvJd59ca9
z&^c_7atb1N5Wp|yvlv`Ih4UbS&j<Lu&z0CX(og2xh~O%KTQ;#c+?kt30?(BLd{m(l
zo5cD_+!P|XC%`?_EDm?#oQUAox54*Il-L`PUdCa+rR0LC%k=~J>Mbk|pU90RV)qC5
lHjNUS&Uz^~ng|}y;a2!}xLGH;0{>-DR7_+-1RK6;>%WS(ux|hW

diff --git a/src/image/mask.rs b/src/image/mask.rs
index 22bb0f9..82c9756 100644
--- a/src/image/mask.rs
+++ b/src/image/mask.rs
@@ -13,8 +13,8 @@ use bevy::{
 };
 
 use crate::{
-    load_asset_if_no_dev_feature, new_effect_state, setup_effect, shader_ref, EffectState,
-    HasEffectState,
+    load_asset_if_no_dev_feature, new_effect_state, passthrough, setup_effect, shader_ref,
+    EffectState, HasEffectState, Passthrough,
 };
 
 const MASKS_SHADER_HANDLE: HandleUntyped =
@@ -102,15 +102,35 @@ impl Mask {
     }
 }
 
-impl From<&MaskMaterial> for MaskVariant {
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+struct MaskKey {
+    variant: MaskVariant,
+    passthrough: bool,
+}
+
+impl Passthrough for MaskKey {
+    fn passthrough(&self) -> bool {
+        self.passthrough
+    }
+}
+
+/// If this effect should not be enabled, i.e. it should just
+/// pass through the input image.
+#[derive(Debug, Resource, Default, PartialEq, Eq, Hash, Clone)]
+pub struct MaskPassthrough(pub bool);
+
+impl From<&MaskMaterial> for MaskKey {
     fn from(mask_material: &MaskMaterial) -> Self {
-        mask_material.variant
+        Self {
+            variant: mask_material.variant,
+            passthrough: mask_material.passthrough,
+        }
     }
 }
 
 #[derive(AsBindGroup, TypeUuid, Clone, Resource)]
 #[uuid = "9ca04144-a3e1-40b4-93a7-91424159f612"]
-#[bind_group_data(MaskVariant)]
+#[bind_group_data(MaskKey)]
 struct MaskMaterial {
     #[texture(0)]
     #[sampler(1)]
@@ -122,6 +142,8 @@ struct MaskMaterial {
     variant: MaskVariant,
 
     state: EffectState,
+
+    passthrough: bool,
 }
 
 impl HasEffectState for MaskMaterial {
@@ -140,7 +162,9 @@ impl Material2d for MaskMaterial {
         _layout: &MeshVertexBufferLayout,
         key: Material2dKey<Self>,
     ) -> Result<(), SpecializedMeshPipelineError> {
-        let def = match key.bind_group_data {
+        passthrough(descriptor, &key);
+
+        let def = match key.bind_group_data.variant {
             MaskVariant::Square => "SQUARE",
             MaskVariant::Crt => "CRT",
             MaskVariant::Vignette => "VIGNETTE",
@@ -166,12 +190,17 @@ impl FromWorld for MaskMaterial {
             strength: mask.strength,
             variant: mask.variant,
             state,
+            passthrough: false,
         }
     }
 }
 
-fn update_mask(mut mask_materials: ResMut<Assets<MaskMaterial>>, mask: Res<Mask>) {
-    if !mask.is_changed() {
+fn update_mask(
+    mut mask_materials: ResMut<Assets<MaskMaterial>>,
+    mask: Res<Mask>,
+    passthrough: Res<MaskPassthrough>,
+) {
+    if !mask.is_changed() && !passthrough.is_changed() {
         return;
     }
 
@@ -188,6 +217,7 @@ impl Plugin for MaskPlugin {
         load_asset_if_no_dev_feature!(app, MASKS_SHADER_HANDLE, "../../assets/shaders/masks.wgsl");
 
         app.init_resource::<MaskMaterial>()
+            .init_resource::<MaskPassthrough>()
             .add_plugin(Material2dPlugin::<MaskMaterial>::default())
             .add_startup_system(setup_effect::<MaskMaterial>)
             .add_system(update_mask);
diff --git a/src/image/pixelate.rs b/src/image/pixelate.rs
index 0ee4642..68f053d 100644
--- a/src/image/pixelate.rs
+++ b/src/image/pixelate.rs
@@ -3,13 +3,19 @@
 use bevy::{
     prelude::*,
     reflect::TypeUuid,
-    render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
-    sprite::{Material2d, Material2dPlugin},
+    render::{
+        mesh::MeshVertexBufferLayout,
+        render_resource::{
+            AsBindGroup, RenderPipelineDescriptor, ShaderRef, ShaderType,
+            SpecializedMeshPipelineError,
+        },
+    },
+    sprite::{Material2d, Material2dKey, Material2dPlugin},
 };
 
 use crate::{
-    load_asset_if_no_dev_feature, new_effect_state, setup_effect, shader_ref, EffectState,
-    HasEffectState,
+    load_asset_if_no_dev_feature, new_effect_state, passthrough, setup_effect, shader_ref,
+    EffectState, HasEffectState, Passthrough,
 };
 
 const PIXELATE_SHADER_HANDLE: HandleUntyped =
@@ -19,7 +25,7 @@ const PIXELATE_SHADER_HANDLE: HandleUntyped =
 /// Add this plugin to the [`App`] in order to use it.
 pub struct PixelatePlugin;
 
-/// Blur parameters.
+/// Pixelation parameters.
 #[derive(Debug, Copy, Clone, Resource, ShaderType)]
 pub struct Pixelate {
     /// How many pixels in the width and height in a block after pixelation.
@@ -35,8 +41,26 @@ impl Default for Pixelate {
     }
 }
 
+/// If this effect should not be enabled, i.e. it should just
+/// pass through the input image.
+#[derive(Debug, Resource, Default, PartialEq, Eq, Hash, Clone)]
+pub struct PixelatePassthrough(pub bool);
+
+impl Passthrough for PixelatePassthrough {
+    fn passthrough(&self) -> bool {
+        self.0
+    }
+}
+
+impl From<&PixelateMaterial> for PixelatePassthrough {
+    fn from(material: &PixelateMaterial) -> Self {
+        Self(material.passthrough)
+    }
+}
+
 #[derive(Debug, AsBindGroup, TypeUuid, Clone, Resource)]
 #[uuid = "6370db4a-50ad-11ed-9fb9-3fa3e5f909b7"]
+#[bind_group_data(PixelatePassthrough)]
 struct PixelateMaterial {
     #[texture(0)]
     #[sampler(1)]
@@ -46,12 +70,24 @@ struct PixelateMaterial {
     pixelate: Pixelate,
 
     state: EffectState,
+
+    passthrough: bool,
 }
 
 impl Material2d for PixelateMaterial {
     fn fragment_shader() -> ShaderRef {
         shader_ref!(PIXELATE_SHADER_HANDLE, "shaders/pixelate.wgsl")
     }
+
+    fn specialize(
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &MeshVertexBufferLayout,
+        key: Material2dKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        passthrough(descriptor, &key);
+
+        Ok(())
+    }
 }
 
 impl HasEffectState for PixelateMaterial {
@@ -69,6 +105,7 @@ impl FromWorld for PixelateMaterial {
             source_image: state.input_image_handle.clone_weak(),
             state,
             pixelate: *pixelate,
+            passthrough: false,
         }
     }
 }
@@ -76,13 +113,15 @@ impl FromWorld for PixelateMaterial {
 fn update_pixelate(
     mut pixelate_materials: ResMut<Assets<PixelateMaterial>>,
     pixelate: Res<Pixelate>,
+    passthrough: Res<PixelatePassthrough>,
 ) {
-    if !pixelate.is_changed() {
+    if !pixelate.is_changed() && !passthrough.is_changed() {
         return;
     }
 
     for (_, material) in pixelate_materials.iter_mut() {
         material.pixelate = *pixelate;
+        material.passthrough = passthrough.0;
     }
 }
 
@@ -98,6 +137,7 @@ impl Plugin for PixelatePlugin {
 
         app.init_resource::<Pixelate>()
             .init_resource::<PixelateMaterial>()
+            .init_resource::<PixelatePassthrough>()
             .add_plugin(Material2dPlugin::<PixelateMaterial>::default())
             .add_startup_system(setup_effect::<PixelateMaterial>)
             .add_system(update_pixelate);
diff --git a/src/image/rainrops.rs b/src/image/raindrops.rs
similarity index 67%
rename from src/image/rainrops.rs
rename to src/image/raindrops.rs
index 5d37cff..45ddc21 100644
--- a/src/image/rainrops.rs
+++ b/src/image/raindrops.rs
@@ -4,18 +4,20 @@ use bevy::{
     prelude::*,
     reflect::TypeUuid,
     render::{
+        mesh::MeshVertexBufferLayout,
         render_resource::{
-            AddressMode, AsBindGroup, SamplerDescriptor, ShaderRef, ShaderType, TextureFormat,
-            TextureViewDescriptor, TextureViewDimension,
+            AddressMode, AsBindGroup, RenderPipelineDescriptor, SamplerDescriptor, ShaderRef,
+            ShaderType, SpecializedMeshPipelineError, TextureFormat, TextureViewDescriptor,
+            TextureViewDimension,
         },
-        texture::ImageSampler,
+        texture::{CompressedImageFormats, ImageSampler},
     },
-    sprite::{Material2d, Material2dPlugin},
+    sprite::{Material2d, Material2dKey, Material2dPlugin},
 };
 
 use crate::{
-    load_asset_if_no_dev_feature, new_effect_state, setup_effect, shader_ref, EffectState,
-    HasEffectState,
+    load_asset_if_no_dev_feature, new_effect_state, passthrough, setup_effect, shader_ref,
+    EffectState, HasEffectState, Passthrough,
 };
 
 const RAINDROPS_SHADER_HANDLE: HandleUntyped =
@@ -24,7 +26,7 @@ const RAINDROPS_SHADER_HANDLE: HandleUntyped =
 /// This plugin allows adding raindrops to an image.
 pub struct RaindropsPlugin;
 
-/// Blur parameters.
+/// Raindrop effect parameters.
 #[derive(Debug, Copy, Clone, Resource, ShaderType)]
 pub struct Raindrops {
     /// How fast the drops animate on screen.
@@ -48,8 +50,26 @@ impl Default for Raindrops {
     }
 }
 
+/// If this effect should not be enabled, i.e. it should just
+/// pass through the input image.
+#[derive(Debug, Resource, Default, PartialEq, Eq, Hash, Clone)]
+pub struct RaindropsPassthrough(pub bool);
+
+impl Passthrough for RaindropsPassthrough {
+    fn passthrough(&self) -> bool {
+        self.0
+    }
+}
+
+impl From<&RaindropsMaterial> for RaindropsPassthrough {
+    fn from(material: &RaindropsMaterial) -> Self {
+        Self(material.passthrough)
+    }
+}
+
 #[derive(Debug, AsBindGroup, TypeUuid, Clone, Resource)]
 #[uuid = "3812649b-8a23-420a-bf03-a87ab11b7c78"]
+#[bind_group_data(RaindropsPassthrough)]
 struct RaindropsMaterial {
     #[texture(0)]
     #[sampler(1)]
@@ -63,6 +83,8 @@ struct RaindropsMaterial {
     raindrops: Raindrops,
 
     state: EffectState,
+
+    passthrough: bool,
 }
 
 impl HasEffectState for RaindropsMaterial {
@@ -75,6 +97,16 @@ impl Material2d for RaindropsMaterial {
     fn fragment_shader() -> ShaderRef {
         shader_ref!(RAINDROPS_SHADER_HANDLE, "shaders/raindrops.wgsl")
     }
+
+    fn specialize(
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &MeshVertexBufferLayout,
+        key: Material2dKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        passthrough(descriptor, &key);
+
+        Ok(())
+    }
 }
 
 impl FromWorld for RaindropsMaterial {
@@ -93,6 +125,7 @@ impl FromWorld for RaindropsMaterial {
             raindrops_image: Some(raindrops_image.0.clone_weak()),
             raindrops: *raindrops,
             state,
+            passthrough: false,
         }
     }
 }
@@ -107,24 +140,46 @@ struct RaindropsImage(Handle<Image>);
 
 impl FromWorld for RaindropsImage {
     fn from_world(world: &mut World) -> Self {
-        let asset_server = world
-            .get_resource::<AssetServer>()
-            .expect("Should have AssetServer");
-
-        Self(asset_server.load("textures/raindrops.tga"))
+        let image_handle = if cfg!(feature = "dev") {
+            let asset_server = world
+                .get_resource::<AssetServer>()
+                .expect("Should have AssetServer");
+
+            asset_server.load("textures/raindrops.tga")
+        } else {
+            use bevy::render::texture::ImageType;
+            let mut image_assets = world
+                .get_resource_mut::<Assets<Image>>()
+                .expect("Should have Assets<Image>");
+
+            let image_bytes = include_bytes!("../../assets/textures/raindrops.tga");
+            let image = Image::from_buffer(
+                image_bytes,
+                ImageType::Extension("tga"),
+                CompressedImageFormats::NONE,
+                true,
+            )
+            .expect("Raindrops tga should load properly");
+
+            image_assets.add(image)
+        };
+
+        Self(image_handle)
     }
 }
 
 fn update_raindrops(
     mut raindrop_materials: ResMut<Assets<RaindropsMaterial>>,
     raindrops: Res<Raindrops>,
+    passthrough: Res<RaindropsPassthrough>,
 ) {
-    if !raindrops.is_changed() {
+    if !raindrops.is_changed() && !passthrough.is_changed() {
         return;
     }
 
     for (_, material) in raindrop_materials.iter_mut() {
         material.raindrops = *raindrops;
+        material.passthrough = passthrough.0;
     }
 }
 
@@ -188,6 +243,7 @@ impl Plugin for RaindropsPlugin {
         app.init_resource::<Raindrops>()
             .init_resource::<RaindropsImage>()
             .init_resource::<RaindropsMaterial>()
+            .init_resource::<RaindropsPassthrough>()
             .add_plugin(Material2dPlugin::<RaindropsMaterial>::default())
             .add_startup_system(setup_effect::<RaindropsMaterial>)
             .add_system(fixup_texture)
diff --git a/src/image/wave.rs b/src/image/wave.rs
index 3700901..5804259 100644
--- a/src/image/wave.rs
+++ b/src/image/wave.rs
@@ -1,13 +1,19 @@
 use bevy::{
     prelude::*,
     reflect::TypeUuid,
-    render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
-    sprite::{Material2d, Material2dPlugin},
+    render::{
+        mesh::MeshVertexBufferLayout,
+        render_resource::{
+            AsBindGroup, RenderPipelineDescriptor, ShaderRef, ShaderType,
+            SpecializedMeshPipelineError,
+        },
+    },
+    sprite::{Material2d, Material2dKey, Material2dPlugin},
 };
 
 use crate::{
-    load_asset_if_no_dev_feature, new_effect_state, setup_effect, shader_ref, EffectState,
-    HasEffectState,
+    load_asset_if_no_dev_feature, new_effect_state, passthrough, setup_effect, shader_ref,
+    EffectState, HasEffectState, Passthrough,
 };
 
 const WAVE_SHADER_HANDLE: HandleUntyped =
@@ -45,8 +51,26 @@ pub struct Wave {
     pub amplitude_y: f32,
 }
 
+/// If this effect should not be enabled, i.e. it should just
+/// pass through the input image.
+#[derive(Debug, Resource, Default, PartialEq, Eq, Hash, Clone)]
+pub struct WavePassthrough(pub bool);
+
+impl Passthrough for WavePassthrough {
+    fn passthrough(&self) -> bool {
+        self.0
+    }
+}
+
+impl From<&WaveMaterial> for WavePassthrough {
+    fn from(material: &WaveMaterial) -> Self {
+        Self(material.passthrough)
+    }
+}
+
 #[derive(Debug, AsBindGroup, TypeUuid, Clone, Resource)]
 #[uuid = "79fa38f9-ca04-4e59-83f9-da0de45afc04"]
+#[bind_group_data(WavePassthrough)]
 struct WaveMaterial {
     #[texture(0)]
     #[sampler(1)]
@@ -56,6 +80,8 @@ struct WaveMaterial {
     wave: Wave,
 
     state: EffectState,
+
+    passthrough: bool,
 }
 
 impl HasEffectState for WaveMaterial {
@@ -68,6 +94,16 @@ impl Material2d for WaveMaterial {
     fn fragment_shader() -> ShaderRef {
         shader_ref!(WAVE_SHADER_HANDLE, "shaders/wave.wgsl")
     }
+
+    fn specialize(
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &MeshVertexBufferLayout,
+        key: Material2dKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        passthrough(descriptor, &key);
+
+        Ok(())
+    }
 }
 
 impl FromWorld for WaveMaterial {
@@ -79,17 +115,23 @@ impl FromWorld for WaveMaterial {
             source_image: state.input_image_handle.clone_weak(),
             state,
             wave: *wave,
+            passthrough: false,
         }
     }
 }
 
-fn update_wave(mut wave_materials: ResMut<Assets<WaveMaterial>>, wave: Res<Wave>) {
-    if !wave.is_changed() {
+fn update_wave(
+    mut wave_materials: ResMut<Assets<WaveMaterial>>,
+    wave: Res<Wave>,
+    passthrough: Res<WavePassthrough>,
+) {
+    if !wave.is_changed() && !passthrough.is_changed() {
         return;
     }
 
     for (_, material) in wave_materials.iter_mut() {
         material.wave = *wave;
+        material.passthrough = passthrough.0;
     }
 }
 
@@ -101,6 +143,7 @@ impl Plugin for WavePlugin {
 
         app.init_resource::<Wave>()
             .init_resource::<WaveMaterial>()
+            .init_resource::<WavePassthrough>()
             .add_plugin(Material2dPlugin::<WaveMaterial>::default())
             .add_startup_system(setup_effect::<WaveMaterial>)
             .add_system(update_wave);
diff --git a/src/lib.rs b/src/lib.rs
index f880909..cadf49a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,28 +4,34 @@
 #![doc = include_str!("../README.md")]
 
 use bevy::{
+    asset::load_internal_asset,
     core_pipeline::clear_color::ClearColorConfig,
     prelude::{App, *},
+    reflect::TypeUuid,
     render::{
         camera::RenderTarget,
         render_resource::{
-            Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
+            Extent3d, RenderPipelineDescriptor, TextureDescriptor, TextureDimension, TextureFormat,
+            TextureUsages,
         },
         texture::BevyDefault,
         view::RenderLayers,
     },
-    sprite::{Material2d, MaterialMesh2dBundle, Mesh2dHandle},
+    sprite::{Material2d, Material2dKey, MaterialMesh2dBundle, Mesh2dHandle},
     window::WindowResized,
 };
 
 use crate::quad::window_sized_quad;
 
+const PASSTHROUGH_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 12989973502425583956);
+
 /// Effects which are added to an image.
 /// This image might be the output of a render pass of an app.
 pub mod image;
 
 /// Helpers for making quads.
-pub mod quad;
+mod quad;
 
 /// For post processing effects to work, this marker should be added to a camera.
 /// This camera will be changed to render to an image buffer which will then be applied
@@ -154,6 +160,7 @@ pub struct BevyVfxBagPlugin;
 /// path. Suitable for hot-reloading.
 /// Else, the shader is loaded via the handle.
 /// Suitable when this crate is used as a dependency.
+#[doc(hidden)]
 #[macro_export]
 macro_rules! shader_ref {
     ($handle: ident, $path_str: expr) => {{
@@ -168,6 +175,7 @@ macro_rules! shader_ref {
 /// Load an asset with the given handle
 /// and relative (to callee source file) path
 /// if the "dev" feature is not on.
+#[doc(hidden)]
 #[macro_export]
 macro_rules! load_asset_if_no_dev_feature {
     ($app: ident, $handle: ident, $path_str: expr) => {{
@@ -176,6 +184,13 @@ macro_rules! load_asset_if_no_dev_feature {
             load_internal_asset!($app, $handle, $path_str, Shader::from_wgsl);
         }
     }};
+
+    ($app: ident, $handle: ident, $path_str: expr, $t: path) => {{
+        if !cfg!(feature = "dev") {
+            use bevy::asset::load_internal_asset;
+            load_internal_asset!($app, $handle, $path_str, $t);
+        }
+    }};
 }
 
 fn new_effect_state(world: &mut World) -> EffectState {
@@ -207,6 +222,25 @@ trait HasEffectState {
     fn state(&self) -> EffectState;
 }
 
+trait Passthrough {
+    fn passthrough(&self) -> bool;
+}
+
+fn passthrough<T>(descriptor: &mut RenderPipelineDescriptor, key: &Material2dKey<T>)
+where
+    T: Material2d,
+    T::Data: Passthrough,
+{
+    if key.bind_group_data.passthrough() {
+        descriptor
+            .fragment
+            .as_mut()
+            .expect("Should have fragment state")
+            .shader_defs
+            .push("PASSTHROUGH".into());
+    }
+}
+
 pub(crate) fn setup_effect<M>(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
@@ -327,6 +361,13 @@ fn setup_post_processing_2d_cameras(
 
 impl Plugin for BevyVfxBagPlugin {
     fn build(&self, app: &mut App) {
+        load_internal_asset!(
+            app,
+            PASSTHROUGH_SHADER_HANDLE,
+            "passthrough.wgsl",
+            Shader::from_wgsl
+        );
+
         app.init_resource::<BevyVfxBagState>()
             .add_startup_system_to_stage(StartupStage::PostStartup, setup_post_processing_input)
             .add_startup_system_to_stage(
diff --git a/src/passthrough.wgsl b/src/passthrough.wgsl
new file mode 100644
index 0000000..6a888f6
--- /dev/null
+++ b/src/passthrough.wgsl
@@ -0,0 +1,19 @@
+#define_import_path bevy_vfx_bag::post_processing_passthrough
+
+@fragment
+fn fragment(
+    @builtin(position) position: vec4<f32>,
+    #import bevy_sprite::mesh2d_vertex_output
+) -> @location(0) vec4<f32> {
+    var uv = coords_to_viewport_uv(position.xy, view.viewport);
+
+    #ifdef PASSTHROUGH
+
+    return vec4<f32>(textureSample(texture, our_sampler, uv).rgb, 1.0);
+
+    #else
+
+    return fragment_impl(position, uv);
+
+    #endif
+}