rename f32::gl_sign() to f32::sign_gl()

Author: Firestar99

shaders/src/a_lot_of_spheres.rs

@@ -150,7 +150,7 @@ impl Inputs {
         // trace grid
         let mut pos: Vec3 = (ro / GRIDSIZE).floor() * GRIDSIZE;
         let ri: Vec3 = 1.0 / rd;
-        let rs: Vec3 = rd.gl_sign() * GRIDSIZE;
+        let rs: Vec3 = rd.sign_gl() * GRIDSIZE;
         let mut dis: Vec3 = (pos - ro + 0.5 * Vec3::splat(GRIDSIZE) + rs * 0.5) * ri;
         let mut mm: Vec3;
 

shaders/src/a_question_of_time.rs

@@ -203,7 +203,7 @@ impl Inputs {
 
             // needles rotation
             let uvrh: Vec2 = uvr_rotate(
-                (hash(Vec2::splat(uv_apo.z)) * d * 180.0).cos().gl_sign()
+                (hash(Vec2::splat(uv_apo.z)) * d * 180.0).cos().sign_gl()
                     * d
                     * self.time
                     * (1.0 / uv_apo.z * 10.0)
@@ -214,7 +214,7 @@ impl Inputs {
             let uvrm: Vec2 = uvr_rotate(
                 (hash(Vec2::splat(uv_apo.z) * 4.0) * d * 180.0)
                     .cos()
-                    .gl_sign()
+                    .sign_gl()
                     * d
                     * self.time
                     * (1.0 / uv_apo.z * 120.0)
@@ -258,7 +258,7 @@ impl Inputs {
             let uvrg: Vec2 = uvr_rotate(
                 (hash(Vec2::splat(uv_apo.z + 2.0)) * d * 180.0)
                     .cos()
-                    .gl_sign()
+                    .sign_gl()
                     * d
                     * self.time
                     * (1.0 / uv_apo.z * 20.0),

shaders/src/geodesic_tiling.rs

@@ -72,7 +72,7 @@ fn p_reflect(p: &mut Vec3, plane_normal: Vec3, offset: f32) -> f32 {
     if t < 0.0 {
         *p = *p - (2. * t) * plane_normal;
     }
-    t.gl_sign()
+    t.sign_gl()
 }
 
 fn smax(a: f32, b: f32, r: f32) -> f32 {

shaders/src/raymarching_primitives.rs

@@ -101,7 +101,7 @@ fn sd_hex_prism(mut p: Vec3, h: Vec2) -> f32 {
     p = p.abs();
     p = (p.xy() - 2.0 * k.xy().dot(p.xy()).min(0.0) * k.xy()).extend(p.z);
     let d: Vec2 = vec2(
-        (p.xy() - vec2(p.x.clamp(-k.z * h.x, k.z * h.x), h.x)).length() * (p.y - h.x).gl_sign(),
+        (p.xy() - vec2(p.x.clamp(-k.z * h.x, k.z * h.x), h.x)).length() * (p.y - h.x).sign_gl(),
         p.z - h.y,
     );
     d.x.max(d.y).min(0.0) + d.max(Vec2::ZERO).length()
@@ -119,7 +119,7 @@ fn sd_octogon_prism(mut p: Vec3, r: f32, h: f32) -> f32 {
     p = (p.xy() - 2.0 * vec2(-k.x, k.y).dot(p.xy()).min(0.0) * vec2(-k.x, k.y)).extend(p.z);
     // polygon side
     p = (p.xy() - vec2(p.x.clamp(-k.z * r, k.z * r), r)).extend(p.z);
-    let d: Vec2 = vec2(p.xy().length() * p.y.gl_sign(), p.z - h);
+    let d: Vec2 = vec2(p.xy().length() * p.y.sign_gl(), p.z - h);
     d.x.max(d.y).min(0.0) + d.max(Vec2::ZERO).length()
 }
 
@@ -164,11 +164,11 @@ fn sd_round_cone(p: Vec3, a: Vec3, b: Vec3, r1: f32, r2: f32) -> f32 {
     let z2: f32 = z * z * l2;
 
     // single square root!
-    let k: f32 = rr.gl_sign() * rr * rr * x2;
-    if z.gl_sign() * a2 * z2 > k {
+    let k: f32 = rr.sign_gl() * rr * rr * x2;
+    if z.sign_gl() * a2 * z2 > k {
         return (x2 + z2).sqrt() * il2 - r2;
     }
-    if y.gl_sign() * a2 * y2 < k {
+    if y.sign_gl() * a2 * y2 < k {
         return (x2 + y2).sqrt() * il2 - r1;
     }
     ((x2 * a2 * il2).sqrt() + y * rr) * il2 - r1
@@ -184,7 +184,7 @@ fn sd_tri_prism(mut p: Vec3, mut h: Vec2) -> f32 {
         p = (vec2(p.x - k * p.y, -k * p.x - p.y) / 2.0).extend(p.z);
     }
     p.x -= p.x.clamp(-2.0, 0.0);
-    let d1: f32 = p.xy().length() * (-p.y).gl_sign() * h.x;
+    let d1: f32 = p.xy().length() * (-p.y).sign_gl() * h.x;
     let d2: f32 = p.z.abs() - h.y;
     vec2(d1, d2).max(Vec2::ZERO).length() + d1.max(d2).min(0.0)
 }
@@ -211,7 +211,7 @@ fn sd_cylinder(p: Vec3, a: Vec3, b: Vec3, r: f32) -> f32 {
     } else {
         (if x > 0.0 { x2 } else { 0.0 }) + if y > 0.0 { y2 } else { 0.0 }
     };
-    d.gl_sign() * d.abs().sqrt() / baba
+    d.sign_gl() * d.abs().sqrt() / baba
 }
 
 // vertical
@@ -221,10 +221,10 @@ fn sd_cone(p: Vec3, c: Vec2, h: f32) -> f32 {
 
     let a: Vec2 = w - q * (w.dot(q) / q.dot(q)).clamp(0.0, 1.0);
     let b: Vec2 = w - q * vec2((w.x / q.x).clamp(0.0, 1.0), 1.0);
-    let k: f32 = q.y.gl_sign();
+    let k: f32 = q.y.sign_gl();
     let d: f32 = a.dot(a).min(b.dot(b));
     let s: f32 = (k * (w.x * q.y - w.y * q.x)).max(k * (w.y - q.y));
-    d.sqrt() * s.gl_sign()
+    d.sqrt() * s.sign_gl()
 }
 
 fn sd_capped_cone_vertical(p: Vec3, h: f32, r1: f32, r2: f32) -> f32 {
@@ -270,7 +270,7 @@ fn sd_solid_angle(pos: Vec3, c: Vec2, ra: f32) -> f32 {
     let p: Vec2 = vec2(pos.xz().length(), pos.y);
     let l: f32 = p.length() - ra;
     let m: f32 = (p - c * p.dot(c).clamp(0.0, ra)).length();
-    l.max(m * (c.y * p.x - c.x * p.y).gl_sign())
+    l.max(m * (c.y * p.x - c.x * p.y).sign_gl())
 }
 
 fn sd_octahedron(mut p: Vec3, s: f32) -> f32 {
@@ -333,7 +333,7 @@ fn sd_pyramid(mut p: Vec3, h: f32) -> f32 {
     };
 
     // recover 3D and scale, and add sign
-    ((d2 + q.z * q.z) / m2).sqrt() * q.z.max(-p.y).gl_sign()
+    ((d2 + q.z * q.z) / m2).sqrt() * q.z.max(-p.y).sign_gl()
 }
 
 // la,lb=semi axis, h=height, ra=corner
@@ -343,7 +343,7 @@ fn sd_rhombus(mut p: Vec3, la: f32, lb: f32, h: f32, ra: f32) -> f32 {
     let f: f32 = (ndot(b, b - 2.0 * p.xz()) / b.dot(b)).clamp(-1.0, 1.0);
     let q: Vec2 = vec2(
         (p.xz() - 0.5 * b * vec2(1.0 - f, 1.0 + f)).length()
-            * (p.x * b.y + p.z * b.x - b.x * b.y).gl_sign()
+            * (p.x * b.y + p.z * b.x - b.x * b.y).sign_gl()
             - ra,
         p.y - h,
     );

shaders/src/skyline.rs

@@ -201,8 +201,8 @@ impl<C0> State<C0> {
             .floor()
             * 0.1;
         let mut mask: f32 = saturate((ray_dir.y * 8.0 - skyline - 2.5 + height) * 24.0);
-        let vert: f32 = (radial * 32.0).sin().gl_sign() * 0.5 + 0.5;
-        let hor: f32 = (ray_dir.y * 256.0).sin().gl_sign() * 0.5 + 0.5;
+        let vert: f32 = (radial * 32.0).sin().sign_gl() * 0.5 + 0.5;
+        let hor: f32 = (ray_dir.y * 256.0).sin().sign_gl() * 0.5 + 0.5;
         mask = saturate(mask + (1.0 - hor * vert) * 0.05);
         final_color = mix(final_color * vec3(0.1, 0.07, 0.05), final_color, mask);
 
@@ -366,7 +366,7 @@ fn city_block(p: Vec3, pint: Vec2) -> Vec2 {
             height + height2,
             (rand2.y - 0.5) * base_rad,
         );
-    let big: f32 = box_pos.x.gl_sign();
+    let big: f32 = box_pos.x.sign_gl();
     box_pos.x = box_pos.x.abs() - 0.02 - base_rad * 0.3 * rand.w;
     d = d.min(sd_box(
         box_pos,
@@ -425,8 +425,8 @@ impl<C0> State<C0> {
 
         rep.z += p2.x.floor(); // shift so less repitition between parallel blocks
         rep.x = repeat(p2.x - 0.5, 1.0); // repeat every block
-        rep.z = rep.z * rep.x.gl_sign(); // mirror but keep cars facing the right way
-        rep.x = (rep.x * rep.x.gl_sign()) - 0.09;
+        rep.z = rep.z * rep.x.sign_gl(); // mirror but keep cars facing the right way
+        rep.x = (rep.x * rep.x.sign_gl()) - 0.09;
         rep.z -= car_time * cross_street; // make cars move
         let unique_id: f32 = (rep.z / repeat_dist).floor(); // each car gets a unique ID that we can use for colors
         rep.z = repeat(rep.z, repeat_dist); // repeat the line of cars every quarter block
@@ -955,7 +955,7 @@ impl<C0: SampleCube> State<C0> {
             final_color *= 0.9;
             // fog that fades to reddish plus the sun color so that fog is brightest towards sun
             let mut rv2: Vec3 = ray_vec;
-            rv2.y *= saturate(rv2.y.gl_sign());
+            rv2.y *= saturate(rv2.y.sign_gl());
             let mut fog_color: Vec3 = self.get_env_map(rv2, self.sun_dir);
             fog_color = Vec3::splat(9.0).min(fog_color);
             final_color = mix(fog_color, final_color, (-t * 0.02).exp());

shaders/src/tokyo.rs

@@ -180,7 +180,7 @@ impl State {
         let mut d: f32;
 
         pd.x = pd.x.abs();
-        pd.z *= -p.x.gl_sign();
+        pd.z *= -p.x.sign_gl();
 
         let ch: f32 = hash(((pd.z + 18.0 * self.time()) / 40.0).floor());
         let lh: f32 = hash((pd.z / 13.0).floor());
@@ -408,7 +408,7 @@ impl State {
 
         let mut pd: Vec3 = pos;
         pd.x = pd.x.abs();
-        pd.z *= -pos.x.gl_sign();
+        pd.z *= -pos.x.sign_gl();
 
         let ch: f32 = hash(((pd.z + 18. * self.time()) / 40.0).floor());
         let mut pdc: Vec3 = vec3(

shaders/src/voxel_pac_man.rs

@@ -165,7 +165,7 @@ impl State {
         let mut ray_length: f32 = 0.0;
         let mut ray_length_in_voxel: f32 = 0.0;
         let mut ray_length_check_voxel: f32 = 0.0;
-        let ray_sign: Vec3 = ray.gl_sign();
+        let ray_sign: Vec3 = ray.sign_gl();
         let ray_delta_voxel: Vec3 = ray_sign / ray;
         for _ in 0..RAY_STEP_MAX {
             if ray_length < ray_length_in_voxel {

shared/src/lib.rs

@@ -75,7 +75,7 @@ impl Clamp for f32 {
 pub trait FloatExt {
     fn fract_gl(self) -> Self;
     fn rem_euclid(self, rhs: Self) -> Self;
-    fn gl_sign(self) -> Self;
+    fn sign_gl(self) -> Self;
     fn step(self, x: Self) -> Self;
 }
 
@@ -93,7 +93,7 @@ impl FloatExt for f32 {
         }
     }
 
-    fn gl_sign(self) -> f32 {
+    fn sign_gl(self) -> f32 {
         if self < 0.0 {
             -1.0
         } else if self == 0.0 {
@@ -119,7 +119,7 @@ pub trait VecExt {
     fn sqrt(self) -> Self;
     fn ln(self) -> Self;
     fn step(self, other: Self) -> Self;
-    fn gl_sign(self) -> Self;
+    fn sign_gl(self) -> Self;
 }
 
 impl VecExt for Vec2 {
@@ -147,8 +147,8 @@ impl VecExt for Vec2 {
         vec2(self.x.step(other.x), self.y.step(other.y))
     }
 
-    fn gl_sign(self) -> Vec2 {
-        vec2(self.x.gl_sign(), self.y.gl_sign())
+    fn sign_gl(self) -> Vec2 {
+        vec2(self.x.sign_gl(), self.y.sign_gl())
     }
 }
 
@@ -181,8 +181,8 @@ impl VecExt for Vec3 {
         )
     }
 
-    fn gl_sign(self) -> Vec3 {
-        vec3(self.x.gl_sign(), self.y.gl_sign(), self.z.gl_sign())
+    fn sign_gl(self) -> Vec3 {
+        vec3(self.x.sign_gl(), self.y.sign_gl(), self.z.sign_gl())
     }
 }
 
@@ -221,12 +221,12 @@ impl VecExt for Vec4 {
         )
     }
 
-    fn gl_sign(self) -> Vec4 {
+    fn sign_gl(self) -> Vec4 {
         vec4(
-            self.x.gl_sign(),
-            self.y.gl_sign(),
-            self.z.gl_sign(),
-            self.w.gl_sign(),
+            self.x.sign_gl(),
+            self.y.sign_gl(),
+            self.z.sign_gl(),
+            self.w.sign_gl(),
         )
     }
 }