rename f32::gl_fract() to f32::fract_gl() to match glam

Firestar99 · Firestar99 · commit fc3bf8226cc6 · 2025-04-15T10:22:28.000+02:00
diff --git a/shaders/src/a_lot_of_spheres.rs b/shaders/src/a_lot_of_spheres.rs
@@ -43,7 +43,7 @@ const SPEED: f32 = 0.5;
 
 const _MR: Mat2 = mat2(vec2(0.84147, 0.54030), vec2(0.54030, -0.84147));
 fn hash(n: f32) -> f32 {
-    (n.sin() * 43758.5453).gl_fract()
+    (n.sin() * 43758.5453).fract_gl()
 }
 fn _hash2(n: f32) -> Vec2 {
     (vec2(n, n + 1.0).sin() * vec2(2.1459123, 3.3490423)).fract_gl()
@@ -105,7 +105,7 @@ impl Inputs {
     fn get_moving_sphere_position(&self, grid: Vec2, sphere_offset: Vec2, center: &mut Vec3) {
         // falling?
         let s: f32 = 0.1 + hash(grid.x * 1.23114 + 5.342 + 74.324231 * grid.y);
-        let t: f32 = (14. * s + self.time / s * 0.3).gl_fract();
+        let t: f32 = (14. * s + self.time / s * 0.3).fract_gl();
 
         let y: f32 = s * MAXHEIGHT * (4.0 * t * (1. - t)).abs();
         let offset: Vec2 = grid + sphere_offset;
diff --git a/shaders/src/a_question_of_time.rs b/shaders/src/a_question_of_time.rs
@@ -74,7 +74,7 @@ fn inversion(uv: Vec2, r: f32) -> Vec2 {
 }
 // seeded random number
 fn hash(s: Vec2) -> f32 {
-    ((s.dot(vec2(12.9898, 78.2333))).sin() * 43758.5453123).gl_fract()
+    ((s.dot(vec2(12.9898, 78.2333))).sin() * 43758.5453123).fract_gl()
 }
 
 // this is an algorithm to construct an apollonian packing with a descartes configuration
diff --git a/shaders/src/filtering_procedurals.rs b/shaders/src/filtering_procedurals.rs
@@ -217,7 +217,7 @@ fn mytexture(mut p: Vec3, _n: Vec3, matid: f32) -> Vec3 {
     let ip: Vec3 = (p / 20.0).floor();
     let fp: Vec3 = (Vec3::splat(0.5) + p / 20.0).fract_gl();
 
-    let mut id: f32 = ((ip.dot(vec3(127.1, 311.7, 74.7))).sin() * 58.5453123).gl_fract();
+    let mut id: f32 = ((ip.dot(vec3(127.1, 311.7, 74.7))).sin() * 58.5453123).fract_gl();
     id = mix(id, 0.3, matid);
 
     let f: f32 = (ip.x + (ip.y + ip.z.rem_euclid(2.0)).rem_euclid(2.0)).rem_euclid(2.0);
diff --git a/shaders/src/geodesic_tiling.rs b/shaders/src/geodesic_tiling.rs
@@ -414,7 +414,7 @@ impl State {
         }
         let t: f32 = self.time / SCENE_DURATION;
         let scene: f32 = t.rem_euclid(3.0).floor();
-        let mut blend: f32 = t.gl_fract();
+        let mut blend: f32 = t.fract_gl();
         let delay: f32 = (SCENE_DURATION - CROSSFADE_DURATION) / SCENE_DURATION;
         blend = (blend - delay).max(0.0) / (1.0 - delay);
         blend = sine_in_out(blend);
diff --git a/shaders/src/luminescence.rs b/shaders/src/luminescence.rs
@@ -87,7 +87,7 @@ const ACCENT_COLOR2: Vec3 = vec3(1.0, 0.5, 0.1);
 const SECOND_COLOR2: Vec3 = vec3(0.1, 0.5, 0.6);
 
 fn _n1(x: f32) -> f32 {
-    (x.sin() * 5346.1764).gl_fract()
+    (x.sin() * 5346.1764).fract_gl()
 }
 fn _n2(x: f32, y: f32) -> f32 {
     _n1(x + y * 23414.324)
@@ -96,7 +96,7 @@ fn _n2(x: f32, y: f32) -> f32 {
 fn n3(mut p: Vec3) -> f32 {
     p = (p * 0.3183099 + Vec3::splat(0.1)).fract_gl();
     p *= 17.0;
-    (p.x * p.y * p.z * (p.x + p.y + p.z)).gl_fract()
+    (p.x * p.y * p.z * (p.x + p.y + p.z)).fract_gl()
 }
 
 #[derive(Clone, Copy, Default)]
@@ -452,7 +452,7 @@ impl State {
 
         let mut s2: f32 = 5. * p.x / TWO_PI;
         let _id: f32 = s2.floor();
-        s2 = s2.gl_fract();
+        s2 = s2.fract_gl();
         let ep: Vec2 = vec2(s2 - 0.5, p.y - 0.6);
         let ed: f32 = ep.length();
         let e: f32 = b(0.35, 0.45, 0.05, ed);
diff --git a/shaders/src/on_off_spikes.rs b/shaders/src/on_off_spikes.rs
@@ -73,14 +73,14 @@ const PIH: f32 = 1.5707963267949;
 const _PI: f32 = 3.1415927;
 const NUM_OCTAVES: i32 = 4;
 fn hash(n: f32) -> f32 {
-    (n.sin() * 1e4).gl_fract()
+    (n.sin() * 1e4).fract_gl()
 }
 fn hash_vec2(p: Vec2) -> f32 {
-    (1e4 * (17.0 * p.x + p.y * 0.1).sin() * (0.1 + (p.y * 13.0 + p.x).sin().abs())).gl_fract()
+    (1e4 * (17.0 * p.x + p.y * 0.1).sin() * (0.1 + (p.y * 13.0 + p.x).sin().abs())).fract_gl()
 }
 fn noise(x: f32) -> f32 {
     let i: f32 = x.floor();
-    let f: f32 = x.gl_fract();
+    let f: f32 = x.fract_gl();
     let u: f32 = f * f * (3.0 - 2.0 * f);
     mix(hash(i), hash(i + 1.0), u)
 }
diff --git a/shaders/src/seascape.rs b/shaders/src/seascape.rs
@@ -71,7 +71,7 @@ fn from_euler(ang: Vec3) -> Mat3 {
 }
 fn hash(p: Vec2) -> f32 {
     let h: f32 = p.dot(vec2(127.1, 311.7));
-    (h.sin() * 43758.5453123).gl_fract()
+    (h.sin() * 43758.5453123).fract_gl()
 }
 fn noise(p: Vec2) -> f32 {
     let i: Vec2 = p.floor();
diff --git a/shaders/src/skyline.rs b/shaders/src/skyline.rs
@@ -85,11 +85,11 @@ fn v21(a: Vec2) -> f32 {
     a.x + a.y * 37.0
 }
 fn hash11(a: f32) -> f32 {
-    (a.sin() * 10403.9).gl_fract()
+    (a.sin() * 10403.9).fract_gl()
 }
 fn hash21(uv: Vec2) -> f32 {
     let f: f32 = uv.x + uv.y * 37.0;
-    (f.sin() * 104003.9).gl_fract()
+    (f.sin() * 104003.9).fract_gl()
 }
 fn hash22(uv: Vec2) -> Vec2 {
     let f: f32 = uv.x + uv.y * 37.0;
@@ -99,15 +99,15 @@ fn _hash12(f: f32) -> Vec2 {
     (f.cos() * vec2(10003.579, 37049.7)).fract_gl()
 }
 fn _hash1d(u: f32) -> f32 {
-    (u.sin() * 143.9).gl_fract() // scale this down to kill the jitters
+    (u.sin() * 143.9).fract_gl() // scale this down to kill the jitters
 }
 fn hash2d(uv: Vec2) -> f32 {
     let f: f32 = uv.x + uv.y * 37.0;
-    (f.sin() * 104003.9).gl_fract()
+    (f.sin() * 104003.9).fract_gl()
 }
 fn hash3d(uv: Vec3) -> f32 {
     let f: f32 = uv.x + uv.y * 37.0 + uv.z * 521.0;
-    (f.sin() * 110003.9).gl_fract()
+    (f.sin() * 110003.9).fract_gl()
 }
 fn mix_p(f0: f32, f1: f32, a: f32) -> f32 {
     mix(f0, f1, a * a * (3.0 - 2.0 * a))
@@ -415,7 +415,7 @@ impl<C0> State<C0> {
         let mut repeat_dist: f32 = 0.25; // Car density bumper to bumper
                                          // If we are going north/south instead of east/west (?) make cars that are
                                          // stopped in the street so we don't have collisions.
-        if (rep.x.gl_fract() - 0.5).abs() < 0.35 {
+        if (rep.x.fract_gl() - 0.5).abs() < 0.35 {
             p2.x += 0.05;
             p2 = (p2.zx() * vec2(-1.0, 1.0)).extend(p2.y).xzy(); // Rotate 90 degrees
             rep = p2.xz().extend(rep.y).xzy();
@@ -463,7 +463,7 @@ fn calc_windows(
     window = window.max(mix(
         0.2,
         1.0,
-        ((pos.y * 20.0 - 0.35).gl_fract() * 2.0 + 0.1).floor(),
+        ((pos.y * 20.0 - 0.35).fract_gl() * 2.0 + 0.1).floor(),
     ));
     if pos.y < 0.05 {
         window = 1.0;
@@ -475,12 +475,12 @@ fn calc_windows(
     window = window.max(mix(
         0.2,
         1.0,
-        ((pos.x * 40.0 + 0.05).gl_fract() * win_width).floor(),
+        ((pos.x * 40.0 + 0.05).fract_gl() * win_width).floor(),
     ));
     window = window.max(mix(
         0.2,
         1.0,
-        ((pos.z * 40.0 + 0.05).gl_fract() * win_width).floor(),
+        ((pos.z * 40.0 + 0.05).fract_gl() * win_width).floor(),
     ));
     if window < 0.5 {
         *window_ref += 1.0;
@@ -547,7 +547,7 @@ impl<C0: SampleCube> State<C0> {
             let t5: f32 = 16.0;
             let t6: f32 = 18.0;*/
             // Repeat the animation after time t6
-            self.local_time = (self.local_time / t6).gl_fract() * t6;
+            self.local_time = (self.local_time / t6).fract_gl() * t6;
             if self.local_time < t1 {
                 let time: f32 = self.local_time - t0;
                 let alpha: f32 = time / (t1 - t0);
@@ -648,16 +648,16 @@ impl<C0: SampleCube> State<C0> {
             // The distance function is not continuous at city block boundaries,
             // so we have to pause our ray march at each voxel boundary.
             let mut walk: f32 = dist_and_mat.x;
-            let mut dx: f32 = -pos.x.gl_fract();
+            let mut dx: f32 = -pos.x.fract_gl();
             if ray_vec.x > 0.0 {
-                dx = (-pos.x).gl_fract();
+                dx = (-pos.x).fract_gl();
             }
-            let mut dz: f32 = -pos.z.gl_fract();
+            let mut dz: f32 = -pos.z.fract_gl();
             if ray_vec.z > 0.0 {
-                dz = (-pos.z).gl_fract();
+                dz = (-pos.z).fract_gl();
             }
             let mut nearest_voxel: f32 =
-                (dx / ray_vec.x).gl_fract().min((dz / ray_vec.z).gl_fract()) + VOXEL_PAD;
+                (dx / ray_vec.x).fract_gl().min((dz / ray_vec.z).fract_gl()) + VOXEL_PAD;
             nearest_voxel = VOXEL_PAD.max(nearest_voxel); // hack that assumes streets and sidewalks are this wide.
                                                           //nearestVoxel = nearestVoxel.max(t * 0.02); // hack to stop voxel walking in the distance.
             walk = walk.min(nearest_voxel);
@@ -729,17 +729,17 @@ impl<C0: SampleCube> State<C0> {
                 }
 
                 let mut walk: f32 = temp_dist;
-                let mut dx: f32 = -shadow_pos.x.gl_fract();
+                let mut dx: f32 = -shadow_pos.x.fract_gl();
                 if self.sun_dir.x > 0.0 {
-                    dx = (-shadow_pos.x).gl_fract();
+                    dx = (-shadow_pos.x).fract_gl();
                 }
-                let mut dz: f32 = -shadow_pos.z.gl_fract();
+                let mut dz: f32 = -shadow_pos.z.fract_gl();
                 if self.sun_dir.z > 0.0 {
-                    dz = (-shadow_pos.z).gl_fract();
+                    dz = (-shadow_pos.z).fract_gl();
                 }
                 let mut nearest_voxel: f32 = (dx / self.sun_dir.x)
-                    .gl_fract()
-                    .min((dz / self.sun_dir.z).gl_fract())
+                    .fract_gl()
+                    .min((dz / self.sun_dir.z).fract_gl())
                     + small_val;
                 nearest_voxel = nearest_voxel.max(0.2); // hack that assumes streets and sidewalks are this wide.
                 walk = walk.min(nearest_voxel);
@@ -825,8 +825,8 @@ impl<C0: SampleCube> State<C0> {
                 normal = (normal + n_temp * 0.2).normalize();
             } else {
                 // Draw the road
-                let xroad: f32 = ((pos.x + 0.5).gl_fract() - 0.5).abs();
-                let zroad: f32 = ((pos.z + 0.5).gl_fract() - 0.5).abs();
+                let xroad: f32 = ((pos.x + 0.5).fract_gl() - 0.5).abs();
+                let zroad: f32 = ((pos.z + 0.5).fract_gl() - 0.5).abs();
                 let road: f32 = saturate((xroad.min(zroad) - 0.143) * 480.0);
                 tex_color *= 1.0 - normal.y * 0.95 * hash21(block * 9.87) * road; // change rooftop color
                 tex_color *= mix(0.1, 1.0, road);
@@ -841,8 +841,8 @@ impl<C0: SampleCube> State<C0> {
                 let mut white_line: f32 = saturate(1.0 - (xroad.min(zroad) - 0.06) * 480.0);
                 white_line *= saturate((xroad.min(zroad) - 0.056) * 480.0);
                 white_line *= saturate((xroad * xroad + zroad * zroad - 0.05) * 880.0);
-                white_line *= saturate(1.0 - ((zroad * 8.0).gl_fract() - 0.5) * 280.0); // dotted line
-                white_line *= saturate(1.0 - ((xroad * 8.0).gl_fract() - 0.5) * 280.0);
+                white_line *= saturate(1.0 - ((zroad * 8.0).fract_gl() - 0.5) * 280.0); // dotted line
+                white_line *= saturate(1.0 - ((xroad * 8.0).fract_gl() - 0.5) * 280.0);
                 tex_color = mix(tex_color, Vec3::splat(0.5), white_line);
 
                 white_line = saturate(1.0 - (xroad.min(zroad) - 0.11) * 480.0);
@@ -851,12 +851,12 @@ impl<C0: SampleCube> State<C0> {
                 tex_color = mix(tex_color, Vec3::splat(0.5), white_line);
 
                 // crosswalk
-                let mut cross_walk: f32 = saturate(1.0 - ((xroad * 40.0).gl_fract() - 0.5) * 280.0);
+                let mut cross_walk: f32 = saturate(1.0 - ((xroad * 40.0).fract_gl() - 0.5) * 280.0);
                 cross_walk *= saturate((zroad - 0.15) * 880.0);
                 cross_walk *= saturate((-zroad + 0.21) * 880.0) * (1.0 - road);
                 cross_walk *= n * n;
                 tex_color = mix(tex_color, Vec3::splat(0.25), cross_walk);
-                cross_walk = saturate(1.0 - ((zroad * 40.0).gl_fract() - 0.5) * 280.0);
+                cross_walk = saturate(1.0 - ((zroad * 40.0).fract_gl() - 0.5) * 280.0);
                 cross_walk *= saturate((xroad - 0.15) * 880.0);
                 cross_walk *= saturate((-xroad + 0.21) * 880.0) * (1.0 - road);
                 cross_walk *= n * n;
@@ -996,9 +996,9 @@ impl<C0: SampleCube> State<C0> {
         let block_res: Vec2 = (self.inputs.resolution.xy() / block_size).floor() + Vec2::ONE;
         // ugly bug with mod.
         //float blockX = mod(frame, blockRes.x);
-        let block_x: f32 = (frame / block_res.x).gl_fract() * block_res.x;
+        let block_x: f32 = (frame / block_res.x).fract_gl() * block_res.x;
         //float blockY = mod(floor(frame / blockRes.x), blockRes.y);
-        let block_y: f32 = ((frame / block_res.x).floor() / block_res.y).gl_fract() * block_res.y;
+        let block_y: f32 = ((frame / block_res.x).floor() / block_res.y).fract_gl() * block_res.y;
         // Don't draw anything outside the current block.
         if (frag_coord.x - block_x * block_size >= block_size)
             || (frag_coord.x - (block_x - 1.0) * block_size < block_size)
diff --git a/shaders/src/soft_shadow_variation.rs b/shaders/src/soft_shadow_variation.rs
@@ -46,7 +46,7 @@ fn sd_box(p: Vec3, b: Vec3) -> f32 {
 //------------------------------------------------------------------
 
 fn map(pos: Vec3) -> f32 {
-    let qos: Vec3 = vec3((pos.x + 0.5).gl_fract() - 0.5, pos.y, pos.z);
+    let qos: Vec3 = vec3((pos.x + 0.5).fract_gl() - 0.5, pos.y, pos.z);
     return sd_plane(pos - vec3(0.0, 0.00, 0.0))
         .min(sd_box(qos - vec3(0.0, 0.25, 0.0), vec3(0.2, 0.5, 0.2)));
 }
@@ -192,7 +192,7 @@ impl Inputs {
         // camera-to-world transformation
         let ca: Mat3 = set_camera(ro, ta, 0.0);
 
-        let technique: i32 = if (self.time / 2.0).gl_fract() > 0.5 {
+        let technique: i32 = if (self.time / 2.0).fract_gl() > 0.5 {
             1
         } else {
             0
diff --git a/shaders/src/tokyo.rs b/shaders/src/tokyo.rs
@@ -76,7 +76,7 @@ impl State {
 // noises
 
 fn hash(n: f32) -> f32 {
-    (n.sin() * 687.3123).gl_fract()
+    (n.sin() * 687.3123).fract_gl()
 }
 
 fn noise(x: Vec2) -> f32 {
diff --git a/shaders/src/voxel_pac_man.rs b/shaders/src/voxel_pac_man.rs
@@ -77,7 +77,7 @@ const SQRT3: f32 = 1.73205080757;
 fn rand(mut seed: Vec3) -> f32 {
     seed = (seed * vec3(5.3983, 5.4427, 6.9371)).fract_gl();
     seed += Vec3::splat(seed.yzx().dot(seed + vec3(21.5351, 14.3137, 15.3219)));
-    (seed.x * seed.y * seed.z * 95.4337).gl_fract()
+    (seed.x * seed.y * seed.z * 95.4337).fract_gl()
 }
 
 impl State {
@@ -263,7 +263,7 @@ impl State {
         let mut mode_angle: f32 = PI * (self.inputs.time * 0.2).cos();
         mode_angle = (frag - vec2((self.inputs.time * 2.0).cos(), 0.0))
             .dot(vec2(mode_angle.cos(), mode_angle.sin()));
-        let mut mode_voxel: f32 = 0.5.step((mode_timing / (4.0 * PI)).gl_fract());
+        let mut mode_voxel: f32 = 0.5.step((mode_timing / (4.0 * PI)).fract_gl());
         mode_timing = mode_timing.cos();
         let mode_3d: f32 = smoothstep(0.8, 0.5, mode_timing);
         let mode_switch: f32 = smoothstep(0.995, 1.0, mode_timing)
diff --git a/shared/src/lib.rs b/shared/src/lib.rs
@@ -73,14 +73,14 @@ impl Clamp for f32 {
 }
 
 pub trait FloatExt {
-    fn gl_fract(self) -> Self;
+    fn fract_gl(self) -> Self;
     fn rem_euclid(self, rhs: Self) -> Self;
     fn gl_sign(self) -> Self;
     fn step(self, x: Self) -> Self;
 }
 
 impl FloatExt for f32 {
-    fn gl_fract(self) -> f32 {
+    fn fract_gl(self) -> f32 {
         self - self.floor()
     }
 

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ fn inversion(uv: Vec2, r: f32) -> Vec2 {`
`74`	`74`	`}`
`75`	`75`	`// seeded random number`
`76`	`76`	`fn hash(s: Vec2) -> f32 {`
`77`		`- ((s.dot(vec2(12.9898, 78.2333))).sin() * 43758.5453123).gl_fract()`
	`77`	`+ ((s.dot(vec2(12.9898, 78.2333))).sin() * 43758.5453123).fract_gl()`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`// this is an algorithm to construct an apollonian packing with a descartes configuration`
Original file line number	Diff line number	Diff line change
`@@ -414,7 +414,7 @@ impl State {`
`414`	`414`	`}`
`415`	`415`	`let t: f32 = self.time / SCENE_DURATION;`
`416`	`416`	`let scene: f32 = t.rem_euclid(3.0).floor();`
`417`		`- let mut blend: f32 = t.gl_fract();`
	`417`	`+ let mut blend: f32 = t.fract_gl();`
`418`	`418`	`let delay: f32 = (SCENE_DURATION - CROSSFADE_DURATION) / SCENE_DURATION;`
`419`	`419`	`blend = (blend - delay).max(0.0) / (1.0 - delay);`
`420`	`420`	`blend = sine_in_out(blend);`
Original file line number	Diff line number	Diff line change
`@@ -73,14 +73,14 @@ const PIH: f32 = 1.5707963267949;`
`73`	`73`	`const _PI: f32 = 3.1415927;`
`74`	`74`	`const NUM_OCTAVES: i32 = 4;`
`75`	`75`	`fn hash(n: f32) -> f32 {`
`76`		`- (n.sin() * 1e4).gl_fract()`
	`76`	`+ (n.sin() * 1e4).fract_gl()`
`77`	`77`	`}`
`78`	`78`	`fn hash_vec2(p: Vec2) -> f32 {`
`79`		`- (1e4 * (17.0 * p.x + p.y * 0.1).sin() * (0.1 + (p.y * 13.0 + p.x).sin().abs())).gl_fract()`
	`79`	`+ (1e4 * (17.0 * p.x + p.y * 0.1).sin() * (0.1 + (p.y * 13.0 + p.x).sin().abs())).fract_gl()`
`80`	`80`	`}`
`81`	`81`	`fn noise(x: f32) -> f32 {`
`82`	`82`	`let i: f32 = x.floor();`
`83`		`- let f: f32 = x.gl_fract();`
	`83`	`+ let f: f32 = x.fract_gl();`
`84`	`84`	`let u: f32 = f * f * (3.0 - 2.0 * f);`
`85`	`85`	`mix(hash(i), hash(i + 1.0), u)`
`86`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ fn from_euler(ang: Vec3) -> Mat3 {`
`71`	`71`	`}`
`72`	`72`	`fn hash(p: Vec2) -> f32 {`
`73`	`73`	`let h: f32 = p.dot(vec2(127.1, 311.7));`
`74`		`- (h.sin() * 43758.5453123).gl_fract()`
	`74`	`+ (h.sin() * 43758.5453123).fract_gl()`
`75`	`75`	`}`
`76`	`76`	`fn noise(p: Vec2) -> f32 {`
`77`	`77`	`let i: Vec2 = p.floor();`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ fn sd_box(p: Vec3, b: Vec3) -> f32 {`
`46`	`46`	`//------------------------------------------------------------------`
`47`	`47`
`48`	`48`	`fn map(pos: Vec3) -> f32 {`
`49`		`- let qos: Vec3 = vec3((pos.x + 0.5).gl_fract() - 0.5, pos.y, pos.z);`
	`49`	`+ let qos: Vec3 = vec3((pos.x + 0.5).fract_gl() - 0.5, pos.y, pos.z);`
`50`	`50`	`return sd_plane(pos - vec3(0.0, 0.00, 0.0))`
`51`	`51`	`.min(sd_box(qos - vec3(0.0, 0.25, 0.0), vec3(0.2, 0.5, 0.2)));`
`52`	`52`	`}`
`@@ -192,7 +192,7 @@ impl Inputs {`
`192`	`192`	`// camera-to-world transformation`
`193`	`193`	`let ca: Mat3 = set_camera(ro, ta, 0.0);`
`194`	`194`
`195`		`- let technique: i32 = if (self.time / 2.0).gl_fract() > 0.5 {`
	`195`	`+ let technique: i32 = if (self.time / 2.0).fract_gl() > 0.5 {`
`196`	`196`	`1`
`197`	`197`	`} else {`
`198`	`198`	`0`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ impl State {`
`76`	`76`	`// noises`
`77`	`77`
`78`	`78`	`fn hash(n: f32) -> f32 {`
`79`		`- (n.sin() * 687.3123).gl_fract()`
	`79`	`+ (n.sin() * 687.3123).fract_gl()`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`fn noise(x: Vec2) -> f32 {`