Remove useless pub.

Author: raldone01

shaders/src/shader_prelude.rs

@@ -1,6 +1,5 @@
-pub use core::f32::consts::{FRAC_1_PI, FRAC_PI_2, PI};
+pub use core::f32::consts::{FRAC_1_PI, FRAC_PI_2, PI, TAU};
 use core::ops::{Add, Mul, Sub};
-pub const TWO_PI: f32 = 2.0 * PI;
 /// We can't use the `f32::consts::SQRT_3` constant here because it is an unstable library feature
 pub const SQRT_3: f32 = 1.732_050_807_568_877_2;
 

shaders/src/shaders/a_lot_of_spheres.rs

@@ -28,9 +28,9 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     Inputs { resolution, time }.main_image(color, frag_coord);
 }
 
-pub struct Inputs {
-    pub resolution: Vec3,
-    pub time: f32,
+struct Inputs {
+    resolution: Vec3,
+    time: f32,
 }
 
 const SHADOW: bool = true;
@@ -255,7 +255,7 @@ impl Inputs {
         color
     }
 
-    pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let q: Vec2 = frag_coord / self.resolution.xy();
         let mut p: Vec2 = Vec2::splat(-1.0) + 2.0 * q;
         p.x *= self.resolution.x / self.resolution.y;

shaders/src/shaders/a_question_of_time.rs

@@ -49,10 +49,10 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     .main_image(color, frag_coord);
 }
 
-pub struct Inputs {
-    pub resolution: Vec3,
-    pub time: f32,
-    pub mouse: Vec4,
+struct Inputs {
+    resolution: Vec3,
+    time: f32,
+    mouse: Vec4,
 }
 
 // a few utility functions
@@ -75,7 +75,7 @@ fn stroke(d: f32, w: f32, s: f32, i: f32) -> f32 {
 }
 // a simple palette
 fn pal(d: f32) -> Vec3 {
-    0.5 * ((TWO_PI * d * vec3(2.0, 2.0, 1.0) + vec3(0.0, 1.4, 0.0)).cos() + Vec3::ONE)
+    0.5 * ((TAU * d * vec3(2.0, 2.0, 1.0) + vec3(0.0, 1.4, 0.0)).cos() + Vec3::ONE)
 }
 // 2d rotation matrix
 fn uvr_rotate(a: f32) -> Mat2 {
@@ -100,7 +100,7 @@ fn apollonian(uv: Vec2) -> Vec3 {
     // a DEC is a configuration of 4 circles tangent to each other
     // the easiest way to build the initial one it to construct a symetric Steiner Chain.
     // http://mathworld.wolfram.com/SteinerChain.html
-    let a: f32 = TWO_PI / 3.;
+    let a: f32 = TAU / 3.;
     let ra: f32 = 1.0 + (a * 0.5).sin();
     let rb: f32 = 1.0 - (a * 0.5).sin();
     dec[0] = vec3(0.0, 0.0, -1.0 / ra);
@@ -321,7 +321,7 @@ impl Inputs {
         c
     }
 
-    pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let uv: Vec2 = (frag_coord - self.resolution.xy() * 0.5) / self.resolution.y;
         let ms: Vec4 = (self.mouse - self.resolution.xyxy() * 0.5) / self.resolution.y;
         *frag_color = self.scene(uv * 4., ms * 4.).extend(1.0);

shaders/src/shaders/apollonian.rs

@@ -33,20 +33,20 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     .main_image(color, frag_coord);
 }
 
-pub struct Inputs {
-    pub resolution: Vec3,
-    pub time: f32,
-    pub mouse: Vec4,
+struct Inputs {
+    resolution: Vec3,
+    time: f32,
+    mouse: Vec4,
 }
 
-pub struct State {
+struct State {
     inputs: Inputs,
     orb: Vec4,
 }
 
 impl State {
     #[must_use]
-    pub fn new(inputs: Inputs) -> Self {
+    fn new(inputs: Inputs) -> Self {
         Self {
             inputs,
             orb: Vec4::ZERO,
@@ -148,7 +148,7 @@ impl State {
         col.sqrt()
     }
 
-    pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let time: f32 = self.inputs.time * 0.25 + 0.01 * self.inputs.mouse.x;
         let anim: f32 = 1.1 + 0.5 * smoothstep(-0.3, 0.3, (0.1 * self.inputs.time).cos());
         let mut tot: Vec3 = Vec3::ZERO;
@@ -185,7 +185,7 @@ impl State {
         *frag_color = tot.extend(1.0);
     }
 
-    pub fn main_vr(
+    fn _main_vr(
         &mut self,
         frag_color: &mut Vec4,
         _frag_coord: Vec2,

shaders/src/shaders/atmosphere_system_test.rs

@@ -33,20 +33,20 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     .main_image(color, frag_coord);
 }
 
-pub struct Inputs {
-    pub resolution: Vec3,
-    pub time: f32,
-    pub mouse: Vec4,
+struct Inputs {
+    resolution: Vec3,
+    time: f32,
+    mouse: Vec4,
 }
 
-pub struct State {
+struct State {
     inputs: Inputs,
     sun_dir: Vec3,
 }
 
 impl State {
     #[must_use]
-    pub fn new(inputs: Inputs) -> Self {
+    fn new(inputs: Inputs) -> Self {
         Self {
             inputs,
             sun_dir: vec3(0.0, 1.0, 0.0),
@@ -255,7 +255,7 @@ impl State {
         SUN_POWER * (sum_r * phase_r * BETA_R + sum_m * phase_m * BETA_M)
     }
 
-    pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let aspect_ratio: Vec2 = vec2(self.inputs.resolution.x / self.inputs.resolution.y, 1.0);
         let fov: f32 = 45.0_f32.to_radians().tan();
         let point_ndc: Vec2 = frag_coord / self.inputs.resolution.xy();

shaders/src/shaders/bubble_buckey_balls.rs

@@ -36,15 +36,15 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     .main_image(color, frag_coord);
 }
 
-pub struct Inputs<C0, C1> {
-    pub resolution: Vec3,
-    pub time: f32,
-    pub mouse: Vec4,
-    pub channel0: C0,
-    pub channel1: C1,
+struct Inputs<C0, C1> {
+    resolution: Vec3,
+    time: f32,
+    mouse: Vec4,
+    channel0: C0,
+    channel1: C1,
 }
 
-pub struct State<C0, C1> {
+struct State<C0, C1> {
     inputs: Inputs<C0, C1>,
 
     cam_point_at: Vec3,
@@ -55,7 +55,7 @@ pub struct State<C0, C1> {
 
 impl<C0, C1> State<C0, C1> {
     #[must_use]
-    pub fn new(inputs: Inputs<C0, C1>) -> Self {
+    fn new(inputs: Inputs<C0, C1>) -> Self {
         Self {
             inputs,
             cam_point_at: Vec3::ZERO,
@@ -337,7 +337,7 @@ impl<C0, C1> State<C0, C1> {
         let cosrotx: f32 = rotx.cos();
         let sinrotx: f32 = rotx.sin();
 
-        let roty: f32 = TWO_PI * click.x + 0.05 * self.time;
+        let roty: f32 = TAU * click.x + 0.05 * self.time;
         let cosroty: f32 = roty.cos();
         let sinroty: f32 = roty.sin();
 
@@ -580,7 +580,7 @@ impl<C0: SampleCube, C1: SampleCube> State<C0, C1> {
     // **************************************************************************
     // MAIN
 
-    pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         // ----------------------------------------------------------------------
         // Animate globals
 

shaders/src/shaders/clouds.rs

@@ -15,9 +15,9 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     Inputs { resolution, time }.main_image(color, frag_coord);
 }
 
-pub struct Inputs {
-    pub resolution: Vec3,
-    pub time: f32,
+struct Inputs {
+    resolution: Vec3,
+    time: f32,
 }
 
 const CLOUD_SCALE: f32 = 1.1;
@@ -74,7 +74,7 @@ fn fbm(mut n: Vec2) -> f32 {
 // -----------------------------------------------
 
 impl Inputs {
-    pub fn main_image(&self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let p: Vec2 = frag_coord / self.resolution.xy();
         let mut uv: Vec2 = p * vec2(self.resolution.x / self.resolution.y, 1.0);
         let mut time: f32 = self.time * SPEED;

shaders/src/shaders/filtering_procedurals.rs

@@ -42,10 +42,10 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     .main_image(color, frag_coord);
 }
 
-pub struct Inputs {
-    pub resolution: Vec3,
-    pub time: f32,
-    pub mouse: Vec4,
+struct Inputs {
+    resolution: Vec3,
+    time: f32,
+    mouse: Vec4,
 }
 
 //===============================================================================================
@@ -351,7 +351,7 @@ fn sample_texture(uvw: Vec3, nor: Vec3, mid: f32) -> Vec3 {
 }
 
 impl Inputs {
-    pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let p: Vec2 = (-self.resolution.xy() + 2.0 * frag_coord) / self.resolution.y;
         let mut th: f32 = (-self.resolution.x + 2.0 * self.mouse.x) / self.resolution.y;
 

shaders/src/shaders/flappy_bird.rs

@@ -25,20 +25,20 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     State::new(Inputs { resolution, time }).main_image(color, frag_coord);
 }
 
-pub struct Inputs {
-    pub resolution: Vec3,
-    pub time: f32,
+struct Inputs {
+    resolution: Vec3,
+    time: f32,
 }
 
-pub struct State {
+struct State {
     inputs: Inputs,
 
     frag_color: Vec4,
 }
 
 impl State {
     #[must_use]
-    pub fn new(inputs: Inputs) -> Self {
+    fn new(inputs: Inputs) -> Self {
         Self {
             inputs,
 
@@ -1237,7 +1237,7 @@ impl State {
         }
     }
 
-    pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let level_pixel: Vec2 = self.get_level_pixel(frag_coord);
 
         self.frag_color = rgb(113, 197, 207); // draw the blue sky background

shaders/src/shaders/galaxy_of_universes.rs

@@ -26,13 +26,13 @@ pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderRes
     Inputs { resolution, time }.main_image(color, frag_coord);
 }
 
-pub struct Inputs {
-    pub resolution: Vec3,
-    pub time: f32,
+struct Inputs {
+    resolution: Vec3,
+    time: f32,
 }
 
 impl Inputs {
-    pub fn main_image(&self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    fn main_image(&self, frag_color: &mut Vec4, frag_coord: Vec2) {
         let uv: Vec2 = (frag_coord / self.resolution.xy()) - Vec2::splat(0.5);
         let t: f32 = self.time * 0.1
             + ((0.25 + 0.05 * (self.time * 0.1).sin()) / (uv.length() + 0.07)) * 2.2;