Use core lib constants.

Author: raldone01

shaders/src/bubble_buckey_balls.rs

@@ -8,7 +8,9 @@
 //! // Tested on Nvidia GTX 780 Windows 7
 //! ```
 
-use crate::{ConstantColor, RgbCube, SampleCube};
+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};
 
@@ -76,10 +78,6 @@ impl<C0, C1> State<C0, C1> {
 // **************************************************************************
 // CONSTANTS
 
-const PI: f32 = 3.14159;
-const TWO_PI: f32 = 6.28318;
-const _PI_OVER_TWO: f32 = 1.570796;
-const ONE_OVER_PI: f32 = 0.318310;
 const GR: f32 = 1.61803398;
 
 const SMALL_FLOAT: f32 = 0.0001;
@@ -471,10 +469,10 @@ impl<C0: SampleCube, C1: SampleCube> State<C0, C1> {
     if ndl > 0. {
       let frk: f32 = 0.5 + 2.0 * costd * costd * surf.roughness;
       let diff: Vec3 = surf.basecolor
-        * ONE_OVER_PI
+        * FRAC_1_PI
         * (1. + (frk - 1.) * pow5(1. - costl))
         * (1. + (frk - 1.) * pow5(1. - costv));
-      //let diff: Vec3 = surf.basecolor * ONE_OVER_PI; // lambert
+      //let diff: Vec3 = surf.basecolor * FRAC_1_PI; // lambert
 
       // D(h) factor
       // using the GGX approximation where the gamma factor is 2.

shaders/src/constants.rs

@@ -0,0 +1,2 @@
+pub const TWO_PI: f32 = 2.0 * core::f32::consts::PI;
+pub const SQRT3: f32 = 1.7320508075688772;

shaders/src/geodesic_tiling.rs

@@ -8,7 +8,7 @@ use spirv_std::glam::{mat2, vec2, vec3, Mat2, Mat3, Vec2, Vec3, Vec3Swizzles, Ve
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::{constants::SQRT3, ShaderDefinition, ShaderInput, ShaderResult};
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "Geodesic Tiling",
@@ -147,15 +147,11 @@ impl State {
 // Adapted from mattz https://www.shadertoy.com/view/4d2GzV
 // --------------------------------------------------------
 
-const SQRT3: f32 = 1.7320508075688772;
 const I3: f32 = 0.5773502691896258;
 
 const CART2HEX: Mat2 = mat2(vec2(1.0, 0.0), vec2(I3, 2.0 * I3));
 const HEX2CART: Mat2 = mat2(vec2(1.0, 0.0), vec2(-0.5, 0.5 * SQRT3));
 
-const _PHI: f32 = 1.618033988749895;
-const _TAU: f32 = 6.283185307179586;
-
 struct TriPoints {
   a: Vec2,
   b: Vec2,

shaders/src/heart.rs

@@ -6,6 +6,8 @@
 //! // License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
 //! ```
 
+use core::f32::consts::PI;
+
 use shared::*;
 use spirv_std::glam::{vec2, vec3, Vec2, Vec3, Vec3Swizzles, Vec4};
 
@@ -36,7 +38,7 @@ pub struct Inputs {
 impl Inputs {
   pub fn main_image(&self, frag_color: &mut Vec4, frag_coord: Vec2) {
     let mut p: Vec2 =
-      (2.0 * frag_coord - self.resolution.xy()) / (self.resolution.y.min(self.resolution.x));
+      (2.0 * frag_coord - self.resolution.xy()) / (self.resolution.xy().min_element());
 
     // background color
     let bcol: Vec3 = vec3(1.0, 0.8, 0.7 - 0.07 * p.y) * (1.0 - 0.25 * p.length());
@@ -58,7 +60,7 @@ impl Inputs {
       d = 0.5;
     } else {
       p.y -= 0.25;
-      let a: f32 = p.x.atan2(p.y) / 3.141593;
+      let a: f32 = p.x.atan2(p.y) / PI;
       r = p.length();
       let h: f32 = a.abs();
       d = (13.0 * h - 22.0 * h * h + 10.0 * h * h * h) / (6.0 - 5.0 * h);

shaders/src/lib.rs

@@ -12,6 +12,7 @@ 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;
@@ -75,7 +76,7 @@ pub struct ShaderResult {
 }
 
 pub struct ShaderDefinition {
-  name: &'static str,
+  pub name: &'static str,
 }
 
 macro_rules! match_index {
@@ -106,7 +107,8 @@ macro_rules! render_shader_macro {
 }
 
 render_shader_macro!(
-  28,
+  29,
+  loading_repeating_circles,
   two_tweets,
   heart,
   clouds,

shaders/src/loading_repeating_circles.rs

@@ -0,0 +1,125 @@
+//! Created by raldone01 :D
+
+use core::f32::consts::PI;
+
+use shared::*;
+use spirv_std::glam::{vec2, vec3, vec4, 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};
+
+pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
+  name: "Loading Repeating Circles",
+};
+
+pub fn shader_fn(render_instruction: &ShaderInput, render_result: &mut ShaderResult) {
+  let color = &mut render_result.color;
+  let (resolution, time, frag_coord) = (
+    render_instruction.resolution,
+    render_instruction.time,
+    render_instruction.frag_coord,
+  );
+  Inputs { resolution, time }.main_image(color, frag_coord)
+}
+
+pub struct Inputs {
+  pub resolution: Vec3,
+  pub time: f32,
+}
+
+fn circle_outline(uv: Vec2, center: Vec2, radius: f32, thickness: f32) -> f32 {
+  // Compute distance from pixel to circle center.
+  let dist = (uv - center).length();
+  // Half thickness for symmetric band.
+  let half_th = thickness * 0.5;
+  // Return 1 if pixel is within the thickness band.
+  return (dist - radius).abs().step(half_th);
+}
+
+/// The speed is in degrees per second.
+fn rotating_discrete_circle(
+  center: Vec2,
+  radius: f32,
+  time: f32,
+  speed: f32,
+  num_circles: i32,
+  cirle_index: i32,
+) -> Vec2 {
+  // convert speed from degrees/sec to radians/sec
+  let speed_rad = speed * PI / 180.0;
+  // angle step between discrete circles
+  let angle_step = 2.0 * PI / num_circles as f32;
+  // base angle for this circle index
+  let base_angle = angle_step * cirle_index as f32;
+  // total rotation angle
+  let angle = base_angle + time * speed_rad;
+  // compute offset from center
+  let offset = vec2(angle.cos(), angle.sin()) * radius;
+  // return world‐space position
+  center + offset
+}
+
+impl Inputs {
+  pub fn main_image(&self, frag_color: &mut Vec4, frag_coord: Vec2) {
+    // Get screen dimensions as Vec2.
+    let screen_xy = self.resolution.xy();
+    // Determine the shorter dimension of the screen.
+    let shorter_dim = screen_xy.min_element();
+
+    // Compute normalized pixel coordinates.
+    // This maps the center of the screen to (0,0) and the shortest side to [-1,1].
+    // Aspect ratio is preserved.
+    let uv = (frag_coord - screen_xy * 0.5) / shorter_dim * 2.0;
+
+    let aspect = screen_xy / shorter_dim;
+
+    let mut combined_mask: f32 = 0.0;
+
+    let center = vec2(0.0, 0.0);
+    let bottom_middle = vec2(0.0, -aspect.y);
+    let top_middle = vec2(0.0, aspect.y);
+    let left_middle = vec2(-aspect.x, 0.0);
+    let right_middle = vec2(aspect.x, 0.0);
+
+    // Define circle radius and outline thickness.
+    // These values are relative to the shorter screen dimension.
+    let radius = 0.3;
+    let thickness = 0.01;
+
+    // Outline masks for center + four midpoints
+    let m_center = circle_outline(uv, center, radius, thickness);
+    combined_mask = combined_mask.max(m_center);
+    let m_bot = circle_outline(uv, bottom_middle, radius, thickness);
+    combined_mask = combined_mask.max(m_bot);
+    let m_top = circle_outline(uv, top_middle, radius, thickness);
+    combined_mask = combined_mask.max(m_top);
+    let m_left = circle_outline(uv, left_middle, radius, thickness);
+    combined_mask = combined_mask.max(m_left);
+    let m_right = circle_outline(uv, right_middle, radius, thickness);
+    combined_mask = combined_mask.max(m_right);
+
+    // rotating circles
+    let num_circles = 8;
+    let speed = 2.0;
+    for i in 0..num_circles {
+      // Compute the position of the circle based on the angle and radius.
+      let pos = rotating_discrete_circle(bottom_middle, 0.5, self.time, speed, num_circles, i);
+      // Compute the outline mask for the current circle.
+      let m = circle_outline(uv, pos, radius, thickness);
+      // Combine masks using max to create a single mask.
+      combined_mask = combined_mask.max(m);
+    }
+
+    // Mix white and black based on mask.
+    // With current mask: outside band (mask=1) is black, inside band (mask=0) is white.
+    // This produces a white outline on a black background.
+    let color_rgb = mix(Vec3::ONE, Vec3::ZERO, combined_mask);
+
+    // Output final pixel color with alpha = 1.0.
+    *frag_color = color_rgb.extend(1.0);
+  }
+}

shaders/src/luminescence.rs

@@ -17,6 +17,8 @@
 //! // Twitter: @The_ArtOfCode
 //! ```
 
+use core::f32::consts::PI;
+
 use shared::*;
 use spirv_std::glam::{vec2, vec3, Mat3, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
 
@@ -25,7 +27,7 @@ use spirv_std::glam::{vec2, vec3, Mat3, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swiz
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::{constants::TWO_PI, ShaderDefinition, ShaderInput, ShaderResult};
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "Luminescence",
@@ -99,10 +101,6 @@ const _LF: Vec3 = vec3(1.0, 0.0, 0.0);
 const UP: Vec3 = vec3(0.0, 1.0, 0.0);
 const _FW: Vec3 = vec3(0.0, 0.0, 1.0);
 
-const _HALF_PI: f32 = 1.570796326794896619;
-const PI: f32 = 3.141592653589793238;
-const TWO_PI: f32 = 6.283185307179586;
-
 const ACCENT_COLOR1: Vec3 = vec3(1.0, 0.1, 0.5);
 const SECOND_COLOR1: Vec3 = vec3(0.1, 0.5, 1.0);
 const ACCENT_COLOR2: Vec3 = vec3(1.0, 0.5, 0.1);

shaders/src/morphing.rs

@@ -6,6 +6,8 @@
 //! // License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
 //! ```
 
+use core::f32::consts::PI;
+
 use shared::*;
 use spirv_std::glam::{
   vec2, vec3, Mat2, Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles,
@@ -16,7 +18,7 @@ use spirv_std::glam::{
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::{constants::TWO_PI, ShaderDefinition, ShaderInput, ShaderResult};
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "Morphing Teapot",
@@ -161,7 +163,7 @@ impl State {
 
     // Distance to other shapes ---------------------------------------------
     let mut d_shape: f32;
-    let id_morph: i32 = ((0.5 + (self.inputs.time) / (2.0 * 3.141592658)).floor() % 3.0) as i32;
+    let id_morph: i32 = ((0.5 + (self.inputs.time) / (TWO_PI)).floor() % 3.0) as i32;
 
     if id_morph == 1 {
       p = (self.mat2_rot.transpose() * p.xz()).extend(p.y).xzy();
@@ -213,7 +215,7 @@ impl State {
   }
 
   pub fn main_image(&mut self, frag_color: &mut Vec4, frag_coord: Vec2) {
-    let aa: f32 = 3.14159 / 4.0;
+    let aa: f32 = PI / 4.0;
     self.mat2_rot = Mat2::from_cols_array(&[aa.cos(), aa.sin(), -aa.sin(), aa.cos()]);
 
     // Morphing step

shaders/src/on_off_spikes.rs

@@ -5,6 +5,8 @@
 //! // On/Off Spikes, fragment shader by movAX13h, oct 2014
 //! ```
 
+use core::f32::consts::FRAC_PI_2;
+
 use shared::*;
 use spirv_std::glam::{
   vec2, vec3, Mat2, Mat3, Vec2, Vec2Swizzles, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles,
@@ -15,7 +17,7 @@ use spirv_std::glam::{
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::{constants::TWO_PI, ShaderDefinition, ShaderInput, ShaderResult};
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "On/Off Spikes",
@@ -86,13 +88,8 @@ const TENTACLE_COL: Vec3 = vec3(0.06, 0.06, 0.06);
 
 const GAMMA: f32 = 2.2;
 
-//---
-const PI2: f32 = 6.283185307179586476925286766559;
-const PIH: f32 = 1.5707963267949;
-
 // Using the nebula function of the "Star map shader" by morgan3d
 // as environment map and light sphere texture (https://www.shadertoy.com/view/4sBXzG)
-const _PI: f32 = 3.1415927;
 const NUM_OCTAVES: i32 = 4;
 fn hash(n: f32) -> f32 {
   (n.sin() * 1e4).fract_gl()
@@ -232,7 +229,7 @@ impl State {
     let mut a: f32 = q.z.atan2(q.x);
     a += 0.4 * (r - self.inputs.time).sin();
 
-    q = vec3(a * NUM_TENTACLES as f32 / PI2, q.y, q.xz().length()); // circular domain
+    q = vec3(a * NUM_TENTACLES as f32 / TWO_PI, q.y, q.xz().length()); // circular domain
     q = vec3(q.x.rem_euclid(1.0) - 0.5 * 1.0, q.y, q.z); // repetition
 
     d3 = sd_capped_cylinder(
@@ -353,9 +350,9 @@ impl State {
       let mrel: Vec2 = self.inputs.mouse.xy() / self.inputs.resolution.xy() - Vec2::splat(0.5);
       let mdis: f32 = 8.0 + 6.0 * mrel.y;
       cp = vec3(
-        mdis * (-mrel.x * PIH).cos(),
+        mdis * (-mrel.x * FRAC_PI_2).cos(),
         4.0 * mrel.y,
-        mdis * (-mrel.x * PIH).sin(),
+        mdis * (-mrel.x * FRAC_PI_2).sin(),
       );
     }
 

shaders/src/phantom_star.rs

@@ -9,7 +9,7 @@ use core::f32::consts::PI;
 #[cfg(target_arch = "spirv")]
 use {shared::FloatExt, spirv_std::num_traits::Float};
 
-use crate::{ShaderDefinition, ShaderInput, ShaderResult};
+use crate::{constants::TWO_PI, ShaderDefinition, ShaderInput, ShaderResult};
 
 pub const SHADER_DEFINITION: ShaderDefinition = ShaderDefinition {
   name: "Phantom Star",
@@ -36,13 +36,9 @@ fn rot(a: f32) -> Mat2 {
   Mat2::from_cols_array(&[c, s, -s, c])
 }
 
-//const pi: f32 = (-1.0).acos();
-const PI_: f32 = PI;
-const PI2: f32 = PI_ * 2.0;
-
 fn pmod(p: Vec2, r: f32) -> Vec2 {
-  let mut a: f32 = p.x.atan2(p.y) + PI_ / r;
-  let n: f32 = PI2 / r;
+  let mut a: f32 = p.x.atan2(p.y) + PI / r;
+  let n: f32 = TWO_PI / r;
   a = (a / n).floor() * n;
   rot(-a).transpose() * p
 }