Use a prelude.

Author: raldone01

shaders/src/lib.rs

@@ -1,143 +1,8 @@
 #![cfg_attr(target_arch = "spirv", no_std)]
 
-use shared::*;
-use spirv_std::{
-  glam::{vec2, vec3, vec4, Vec2, Vec3, Vec4},
-  spirv,
-};
-
-pub mod a_lot_of_spheres;
-pub mod a_question_of_time;
-pub mod apollonian;
-pub mod atmosphere_system_test;
-pub mod bubble_buckey_balls;
-pub mod clouds;
-pub mod constants;
-pub mod filtering_procedurals;
-pub mod flappy_bird;
-pub mod galaxy_of_universes;
-pub mod geodesic_tiling;
-pub mod heart;
-pub mod loading_repeating_circles;
-pub mod luminescence;
-pub mod mandelbrot_smooth;
-pub mod miracle_snowflakes;
-pub mod morphing;
-pub mod moving_square;
-pub mod on_off_spikes;
-pub mod phantom_star;
-pub mod playing_marble;
-pub mod protean_clouds;
-pub mod raymarching_primitives;
-pub mod seascape;
-pub mod skyline;
-pub mod soft_shadow_variation;
-pub mod tileable_water_caustic;
-pub mod tokyo;
-pub mod two_tweets;
-pub mod voxel_pac_man;
-
-pub trait SampleCube: Copy {
-  fn sample_cube(self, p: Vec3) -> Vec4;
-}
-
-#[derive(Copy, Clone)]
-struct ConstantColor {
-  color: Vec4,
-}
-
-impl SampleCube for ConstantColor {
-  fn sample_cube(self, _: Vec3) -> Vec4 {
-    self.color
-  }
-}
-
-#[derive(Copy, Clone)]
-struct RgbCube {
-  alpha: f32,
-  intensity: f32,
-}
-
-impl SampleCube for RgbCube {
-  fn sample_cube(self, p: Vec3) -> Vec4 {
-    (p.abs() * self.intensity).extend(self.alpha)
-  }
-}
-
-pub struct ShaderInput {
-  resolution: Vec3,
-  time: f32,
-  frag_coord: Vec2,
-  mouse: Vec4,
-}
-
-pub struct ShaderResult {
-  color: Vec4,
-}
-
-pub struct ShaderDefinition {
-  pub name: &'static str,
-}
-
-macro_rules! match_index {
-    ($e:expr; $($result:expr),* $(,)?) => ({
-        let mut i = 0..;
-        match $e { e => {
-            $(if e == i.next().unwrap() { $result } else)*
-            { unreachable!() }
-        }}
-    })
-}
-
-macro_rules! render_shader_macro {
-    ($num_shaders:expr, $($shader_name:ident),* $(,)?) => {
-        #[inline(always)]
-        pub fn render_shader(shader_index: u32, shader_input: &ShaderInput, shader_output: &mut ShaderResult) {
-            match_index!(shader_index; $(
-                $shader_name::shader_fn(shader_input, shader_output),
-            )*)
-        }
-
-        pub const SHADER_DEFINITIONS: [ShaderDefinition; $num_shaders] = [
-            $(
-                $shader_name::SHADER_DEFINITION,
-            )*
-        ];
-    };
-}
-
-render_shader_macro!(
-  29,
-  loading_repeating_circles,
-  two_tweets,
-  heart,
-  clouds,
-  mandelbrot_smooth,
-  protean_clouds,
-  tileable_water_caustic,
-  apollonian,
-  phantom_star,
-  seascape,
-  playing_marble,
-  a_lot_of_spheres,
-  a_question_of_time,
-  galaxy_of_universes,
-  atmosphere_system_test,
-  soft_shadow_variation,
-  miracle_snowflakes,
-  morphing,
-  bubble_buckey_balls,
-  raymarching_primitives,
-  moving_square,
-  skyline,
-  filtering_procedurals,
-  geodesic_tiling,
-  flappy_bird,
-  tokyo,
-  on_off_spikes,
-  luminescence,
-  voxel_pac_man,
-);
+pub mod shader_prelude;
+use shader_prelude::*;
+pub mod shaders;
 
 #[inline(always)]
 pub fn fs(constants: &ShaderConstants, mut frag_coord: Vec2) -> Vec4 {
@@ -174,7 +39,7 @@ pub fn fs(constants: &ShaderConstants, mut frag_coord: Vec2) -> Vec4 {
     mouse,
   };
   let mut shader_output = &mut ShaderResult { color: Vec4::ZERO };
-  render_shader(constants.shader_to_show, &shader_input, &mut shader_output);
+  shaders::render_shader(constants.shader_to_show, &shader_input, &mut shader_output);
   let color = shader_output.color;
   Vec3::powf(color.truncate(), 2.2).extend(color.w)
 }

shaders/src/prelude.rs

@@ -0,0 +1,60 @@
+pub use core::f32::consts::{FRAC_1_PI, FRAC_PI_2, PI};
+pub const TWO_PI: f32 = 2.0 * PI;
+pub const SQRT3: f32 = 1.7320508075688772;
+
+pub use shared::*;
+pub use spirv_std::{
+  arch::Derivative,
+  glam::{
+    mat2, mat3, vec2, vec3, vec4, Mat2, Mat3, Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4,
+    Vec4Swizzles,
+  },
+  spirv,
+};
+
+// Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
+// we tie #[no_std] above to the same condition, so it's fine.
+#[cfg(target_arch = "spirv")]
+pub use spirv_std::num_traits::Float;
+
+pub trait SampleCube: Copy {
+  fn sample_cube(self, p: Vec3) -> Vec4;
+}
+
+#[derive(Copy, Clone)]
+pub struct ConstantColor {
+  pub color: Vec4,
+}
+
+impl SampleCube for ConstantColor {
+  fn sample_cube(self, _: Vec3) -> Vec4 {
+    self.color
+  }
+}
+
+#[derive(Copy, Clone)]
+pub struct RgbCube {
+  pub alpha: f32,
+  pub intensity: f32,
+}
+
+impl SampleCube for RgbCube {
+  fn sample_cube(self, p: Vec3) -> Vec4 {
+    (p.abs() * self.intensity).extend(self.alpha)
+  }
+}
+
+pub struct ShaderInput {
+  pub resolution: Vec3,
+  pub time: f32,
+  pub frag_coord: Vec2,
+  pub mouse: Vec4,
+}
+
+pub struct ShaderResult {
+  pub color: Vec4,
+}
+
+pub struct ShaderDefinition {
+  pub name: &'static str,
+}

shaders/src/shader_prelude.rs

@@ -11,15 +11,7 @@
 //! */
 //! ```
 
-use shared::*;
-use spirv_std::glam::{mat2, vec2, vec3, Mat2, Vec2, Vec3, Vec3Swizzles, Vec4};
-
-// Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
-// we tie #[no_std] above to the same condition, so it's fine.
-#[cfg(target_arch = "spirv")]
-use spirv_std::num_traits::Float;
-
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::shader_prelude::*;
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "A Lot of Spheres",

shaders/src/shaders/a_lot_of_spheres.rs

@@ -26,17 +26,7 @@
 //! */
 //! ```
 
-use shared::*;
-use spirv_std::glam::{
-  vec2, vec3, Mat2, Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles,
-};
-
-// Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
-// we tie #[no_std] above to the same condition, so it's fine.
-#[cfg(target_arch = "spirv")]
-use spirv_std::num_traits::Float;
-
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::shader_prelude::*;
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "A Question of Time",

shaders/src/shaders/a_question_of_time.rs

@@ -10,15 +10,7 @@
 //! // Coloring and fake occlusions are done by orbit trapping, as usual.
 //! ```
 
-use shared::*;
-use spirv_std::glam::{vec2, vec3, Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4};
-
-// Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
-// we tie #[no_std] above to the same condition, so it's fine.
-#[cfg(target_arch = "spirv")]
-use spirv_std::num_traits::Float;
-
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::shader_prelude::*;
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "Apollonian Fractal",

shaders/src/shaders/apollonian.rs

@@ -10,14 +10,7 @@
 //! // ----------------------------------------------------------------------------
 //! ```
 
-use spirv_std::glam::{vec2, vec3, Mat3, Vec2, Vec3, Vec3Swizzles, Vec4};
-
-// Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
-// we tie #[no_std] above to the same condition, so it's fine.
-#[cfg(target_arch = "spirv")]
-use spirv_std::num_traits::Float;
-
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::shader_prelude::*;
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "Atmosphere System Test",

shaders/src/shaders/atmosphere_system_test.rs

@@ -8,18 +8,7 @@
 //! // Tested on Nvidia GTX 780 Windows 7
 //! ```
 
-use core::f32::consts::{FRAC_1_PI, PI};
-
-use crate::{constants::TWO_PI, ConstantColor, RgbCube, SampleCube};
-use shared::*;
-use spirv_std::glam::{vec2, vec3, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
-
-// Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
-// we tie #[no_std] above to the same condition, so it's fine.
-#[cfg(target_arch = "spirv")]
-use spirv_std::num_traits::Float;
-
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::shader_prelude::*;
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "Bubble Buckey Balls",

shaders/src/shaders/bubble_buckey_balls.rs

@@ -1,9 +1,6 @@
 //! Ported to Rust from <https://www.shadertoy.com/view/4tdSWr>
 
-use shared::*;
-use spirv_std::glam::{mat2, vec2, vec3, Mat2, Vec2, Vec3, Vec3Swizzles, Vec4};
-
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::shader_prelude::*;
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition { name: "Clouds" };
 

shaders/src/shaders/clouds.rs

@@ -19,18 +19,7 @@
 //! */
 //! ```
 
-use shared::*;
-use spirv_std::{
-  arch::Derivative,
-  glam::{vec2, vec3, vec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles},
-};
-
-// Note: This cfg is incorrect on its surface, it really should be "are we compiling with std", but
-// we tie #[no_std] above to the same condition, so it's fine.
-#[cfg(target_arch = "spirv")]
-use spirv_std::num_traits::Float;
-
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::shader_prelude::*;
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "Filtering Procedurals",