inline new glam methods

Firestar99 · Firestar99 · commit cd0244138def · 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
@@ -46,16 +46,16 @@ fn hash(n: f32) -> f32 {
     (n.sin() * 43758.5453).gl_fract()
 }
 fn _hash2(n: f32) -> Vec2 {
-    (vec2(n, n + 1.0).sin() * vec2(2.1459123, 3.3490423)).gl_fract()
+    (vec2(n, n + 1.0).sin() * vec2(2.1459123, 3.3490423)).fract_gl()
 }
 fn hash2_vec(n: Vec2) -> Vec2 {
-    (vec2(n.x * n.y, n.x + n.y).sin() * vec2(2.1459123, 3.3490423)).gl_fract()
+    (vec2(n.x * n.y, n.x + n.y).sin() * vec2(2.1459123, 3.3490423)).fract_gl()
 }
 fn _hash3(n: f32) -> Vec3 {
-    (vec3(n, n + 1.0, n + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).gl_fract()
+    (vec3(n, n + 1.0, n + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).fract_gl()
 }
 fn hash3_vec(n: Vec2) -> Vec3 {
-    (vec3(n.x, n.y, n.x + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).gl_fract()
+    (vec3(n.x, n.y, n.x + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).fract_gl()
 }
 
 //
diff --git a/shaders/src/a_question_of_time.rs b/shaders/src/a_question_of_time.rs
@@ -159,7 +159,7 @@ impl Inputs {
 
         // drag your mouse to apply circle inversion
         if ms.y != -2.0 && ms.w > -2.0 {
-            uv = inversion(uv, (60.0.deg_to_radians()).cos());
+            uv = inversion(uv, 60.0.to_radians().cos());
             ci = ms.xy();
         }
 
diff --git a/shaders/src/apollonian.rs b/shaders/src/apollonian.rs
@@ -53,7 +53,7 @@ impl State {
         self.orb = Vec4::splat(1000.0);
         let mut i = 0;
         while i < 8 {
-            p = Vec3::splat(-1.0) + 2.0 * (0.5 * p + Vec3::splat(0.5)).gl_fract();
+            p = Vec3::splat(-1.0) + 2.0 * (0.5 * p + Vec3::splat(0.5)).fract_gl();
 
             let r2: f32 = p.dot(p);
 
diff --git a/shaders/src/atmosphere_system_test.rs b/shaders/src/atmosphere_system_test.rs
@@ -10,7 +10,6 @@
 //! // ----------------------------------------------------------------------------
 //! ```
 
-use shared::*;
 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
@@ -60,7 +59,7 @@ struct _Plane {
 }
 
 fn rotate_around_x(angle_degrees: f32) -> Mat3 {
-    let angle: f32 = angle_degrees.deg_to_radians();
+    let angle: f32 = angle_degrees.to_radians();
     let _sin: f32 = angle.sin();
     let _cos: f32 = angle.cos();
     Mat3::from_cols_array(&[1.0, 0.0, 0.0, 0.0, _cos, -_sin, 0.0, _sin, _cos])
@@ -230,7 +229,7 @@ impl State {
             if overground {
                 let tau: Vec3 = BETA_R * (optical_depth_r + optical_depth_light_r)
                     + BETA_M * 1.1 * (optical_depth_m + optical_depth_light_m);
-                let attenuation: Vec3 = exp(-tau);
+                let attenuation: Vec3 = Vec3::exp(-tau);
 
                 sum_r += hr * attenuation;
                 sum_m += hm * attenuation;
@@ -245,7 +244,7 @@ impl State {
 
     pub 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.deg_to_radians().tan();
+        let fov: f32 = 45.0.to_radians().tan();
         let point_ndc: Vec2 = frag_coord / self.inputs.resolution.xy();
         let point_cam: Vec3 = ((2.0 * point_ndc - Vec2::ONE) * aspect_ratio * fov).extend(-1.0);
 
diff --git a/shaders/src/clouds.rs b/shaders/src/clouds.rs
@@ -27,7 +27,7 @@ const M: Mat2 = mat2(vec2(1.6, 1.2), vec2(-1.2, 1.6));
 
 fn hash(mut p: Vec2) -> Vec2 {
     p = vec2(p.dot(vec2(127.1, 311.7)), p.dot(vec2(269.5, 183.3)));
-    Vec2::splat(-1.0) + 2.0 * (p.sin() * 43758.5453123).gl_fract()
+    Vec2::splat(-1.0) + 2.0 * (p.sin() * 43758.5453123).fract_gl()
 }
 
 fn noise(p: Vec2) -> f32 {
diff --git a/shaders/src/filtering_procedurals.rs b/shaders/src/filtering_procedurals.rs
@@ -52,12 +52,12 @@ fn hash3(mut p: Vec3) -> Vec3 {
         p.dot(vec3(113.5, 271.9, 124.6)),
     );
 
-    -Vec3::ONE + 2.0 * (p.sin() * 13.5453123).gl_fract()
+    -Vec3::ONE + 2.0 * (p.sin() * 13.5453123).fract_gl()
 }
 
 fn noise(p: Vec3) -> f32 {
     let i: Vec3 = p.floor();
-    let f: Vec3 = p.gl_fract();
+    let f: Vec3 = p.fract_gl();
 
     let u: Vec3 = f * f * (Vec3::splat(3.0) - 2.0 * f);
 
@@ -215,7 +215,7 @@ fn tex_coords(p: Vec3) -> Vec3 {
 fn mytexture(mut p: Vec3, _n: Vec3, matid: f32) -> Vec3 {
     p += Vec3::splat(0.1);
     let ip: Vec3 = (p / 20.0).floor();
-    let fp: Vec3 = (Vec3::splat(0.5) + p / 20.0).gl_fract();
+    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();
     id = mix(id, 0.3, matid);
diff --git a/shaders/src/geodesic_tiling.rs b/shaders/src/geodesic_tiling.rs
@@ -147,7 +147,7 @@ struct TriPoints {
 fn closest_tri_points(p: Vec2) -> TriPoints {
     let p_tri: Vec2 = CART2HEX * p;
     let pi: Vec2 = p_tri.floor();
-    let pf: Vec2 = p_tri.gl_fract();
+    let pf: Vec2 = p_tri.fract_gl();
 
     let split1: f32 = pf.y.step(pf.x);
     let split2: f32 = pf.x.step(pf.y);
diff --git a/shaders/src/lib.rs b/shaders/src/lib.rs
@@ -223,7 +223,7 @@ pub fn fs(constants: &ShaderConstants, mut frag_coord: Vec2) -> Vec4 {
         .main_image(&mut color, frag_coord),
         _ => {}
     }
-    pow(color.truncate(), 2.2).extend(color.w)
+    Vec3::powf(color.truncate(), 2.2).extend(color.w)
 }
 
 #[allow(unused_attributes)]
diff --git a/shaders/src/luminescence.rs b/shaders/src/luminescence.rs
@@ -94,7 +94,7 @@ fn _n2(x: f32, y: f32) -> f32 {
 }
 
 fn n3(mut p: Vec3) -> f32 {
-    p = (p * 0.3183099 + Vec3::splat(0.1)).gl_fract();
+    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()
 }
@@ -145,7 +145,7 @@ fn repeat(pos: Vec3, size: Vec3) -> Rc {
     o.h = size * 0.5;
     o.id = (pos / size).floor(); // used to give a unique id to each cell
 
-    o.p = pos.rem_euclid_vec(size) - o.h;
+    o.p = pos.rem_euclid(size) - o.h;
     //o.c = o.id*size+o.h;
 
     o
@@ -172,14 +172,14 @@ impl State {
 
 //  3 out, 1 in... DAVE HOSKINS
 fn n31(p: f32) -> Vec3 {
-    let mut p3: Vec3 = (Vec3::splat(p) * vec3(0.1031, 0.11369, 0.13787)).gl_fract();
+    let mut p3: Vec3 = (Vec3::splat(p) * vec3(0.1031, 0.11369, 0.13787)).fract_gl();
     p3 += Vec3::splat(p3.dot(p3.yzx() + Vec3::splat(19.19)));
     vec3(
         (p3.x + p3.y) * p3.z,
         (p3.x + p3.z) * p3.y,
         (p3.y + p3.z) * p3.x,
     )
-    .gl_fract()
+    .fract_gl()
 }
 
 // DE functions from IQ
diff --git a/shaders/src/miracle_snowflakes.rs b/shaders/src/miracle_snowflakes.rs
@@ -74,11 +74,11 @@ const NC0: Vec4 = vec4(0.0, 157.0, 113.0, 270.0);
 const NC1: Vec4 = vec4(1.0, 158.0, 114.0, 271.0);
 
 fn hash4(n: Vec4) -> Vec4 {
-    (n.sin() * 1399763.5453123).gl_fract()
+    (n.sin() * 1399763.5453123).fract_gl()
 }
 fn noise2(x: Vec2) -> f32 {
     let p: Vec2 = x.floor();
-    let mut f: Vec2 = x.gl_fract();
+    let mut f: Vec2 = x.fract_gl();
     f = f * f * (Vec2::splat(3.0) - 2.0 * f);
     let n: f32 = p.x + p.y * 157.0;
     let nc0 = NC0;
@@ -91,7 +91,7 @@ fn noise2(x: Vec2) -> f32 {
 fn noise222(x: Vec2, y: Vec2, z: Vec2) -> f32 {
     let lx: Vec4 = vec4(x.x * y.x, x.y * y.x, x.x * y.y, x.y * y.y);
     let p: Vec4 = lx.floor();
-    let mut f: Vec4 = lx.gl_fract();
+    let mut f: Vec4 = lx.fract_gl();
     f = f * f * (Vec4::splat(3.0) - 2.0 * f);
     let n: Vec2 = p.xz() + p.yw() * 157.0;
     let h: Vec4 = mix(
@@ -104,7 +104,7 @@ fn noise222(x: Vec2, y: Vec2, z: Vec2) -> f32 {
 
 fn noise3(x: Vec3) -> f32 {
     let p: Vec3 = x.floor();
-    let mut f: Vec3 = x.gl_fract();
+    let mut f: Vec3 = x.fract_gl();
     f = f * f * (Vec3::splat(3.0) - 2.0 * f);
     let n: f32 = p.x + p.yz().dot(vec2(157.0, 113.0));
     let s1: Vec4 = mix(
diff --git a/shaders/src/on_off_spikes.rs b/shaders/src/on_off_spikes.rs
@@ -86,7 +86,7 @@ fn noise(x: f32) -> f32 {
 }
 fn noise_vec2(x: Vec2) -> f32 {
     let i: Vec2 = x.floor();
-    let f: Vec2 = x.gl_fract();
+    let f: Vec2 = x.fract_gl();
     let a: f32 = hash_vec2(i);
     let b: f32 = hash_vec2(i + vec2(1.0, 0.0));
     let c: f32 = hash_vec2(i + vec2(0.0, 1.0));
diff --git a/shaders/src/raymarching_primitives.rs b/shaders/src/raymarching_primitives.rs
@@ -692,8 +692,8 @@ fn checkers_grad_box(p: Vec2, dpdx: Vec2, dpdy: Vec2) -> f32 {
     let w: Vec2 = dpdx.abs() + dpdy.abs() + Vec2::splat(0.001);
     // analytical integral (box filter)
     let i: Vec2 = 2.0
-        * ((((p - 0.5 * w) * 0.5).gl_fract() - Vec2::splat(0.5)).abs()
-            - (((p + 0.5 * w) * 0.5).gl_fract() - Vec2::splat(0.5)).abs())
+        * ((((p - 0.5 * w) * 0.5).fract_gl() - Vec2::splat(0.5)).abs()
+            - (((p + 0.5 * w) * 0.5).fract_gl() - Vec2::splat(0.5)).abs())
         / w;
     // xor pattern
     0.5 - 0.5 * i.x * i.y
diff --git a/shaders/src/seascape.rs b/shaders/src/seascape.rs
@@ -75,7 +75,7 @@ fn hash(p: Vec2) -> f32 {
 }
 fn noise(p: Vec2) -> f32 {
     let i: Vec2 = p.floor();
-    let f: Vec2 = p.gl_fract();
+    let f: Vec2 = p.fract_gl();
     let u: Vec2 = f * f * (Vec2::splat(3.0) - 2.0 * f);
     -1.0 + 2.0
         * mix(
diff --git a/shaders/src/skyline.rs b/shaders/src/skyline.rs
@@ -93,10 +93,10 @@ fn hash21(uv: Vec2) -> f32 {
 }
 fn hash22(uv: Vec2) -> Vec2 {
     let f: f32 = uv.x + uv.y * 37.0;
-    (f.cos() * vec2(10003.579, 37049.7)).gl_fract()
+    (f.cos() * vec2(10003.579, 37049.7)).fract_gl()
 }
 fn _hash12(f: f32) -> Vec2 {
-    (f.cos() * vec2(10003.579, 37049.7)).gl_fract()
+    (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
@@ -114,7 +114,7 @@ fn mix_p(f0: f32, f1: f32, a: f32) -> f32 {
 }
 const ZERO_ONE: Vec2 = vec2(0.0, 1.0);
 fn noise2d(uv: Vec2) -> f32 {
-    let fr: Vec2 = uv.gl_fract();
+    let fr: Vec2 = uv.fract_gl();
     let fl: Vec2 = uv.floor();
     let h00: f32 = hash2d(fl);
     let h10: f32 = hash2d(fl + ZERO_ONE.yx());
@@ -123,7 +123,7 @@ fn noise2d(uv: Vec2) -> f32 {
     mix_p(mix_p(h00, h10, fr.x), mix_p(h01, h11, fr.x), fr.y)
 }
 fn noise(uv: Vec3) -> f32 {
-    let fr: Vec3 = uv.gl_fract();
+    let fr: Vec3 = uv.fract_gl();
     let fl: Vec3 = uv.floor();
     let h000: f32 = hash3d(fl);
     let h100: f32 = hash3d(fl + ZERO_ONE.yxx());
@@ -402,7 +402,7 @@ impl<C0> State<C0> {
     fn distance_to_object(&self, p: Vec3) -> Vec2 {
         //p.y += noise2d((p.xz)*0.0625)*8.0; // Hills
         let mut rep: Vec3 = p;
-        rep = (p.xz().gl_fract()).extend(rep.y).xzy(); // [0..1] for representing the position in the city block
+        rep = (p.xz().fract_gl()).extend(rep.y).xzy(); // [0..1] for representing the position in the city block
         let mut dist_and_mat: Vec2 = city_block(rep, p.xz().floor());
 
         // Set up the cars. This is doing a lot of mirroring and repeating because I
diff --git a/shaders/src/tileable_water_caustic.rs b/shaders/src/tileable_water_caustic.rs
@@ -70,7 +70,7 @@ impl Inputs {
 
             let f: f32 = (self.time * 0.5).rem_euclid(2.0).floor(); // Flash value.
             let first: Vec2 = pixel.step(uv) * f; // Rule out first screen pixels and flash.
-            uv = uv.gl_fract().step(pixel); // Add one line of pixels per tile.
+            uv = uv.fract_gl().step(pixel); // Add one line of pixels per tile.
             colour = mix(
                 colour,
                 vec3(1.0, 1.0, 0.0),
diff --git a/shaders/src/tokyo.rs b/shaders/src/tokyo.rs
@@ -81,7 +81,7 @@ fn hash(n: f32) -> f32 {
 
 fn noise(x: Vec2) -> f32 {
     let p: Vec2 = x.floor();
-    let mut f: Vec2 = x.gl_fract();
+    let mut f: Vec2 = x.fract_gl();
     f = f * f * (Vec2::splat(3.0) - 2.0 * f);
     let n: f32 = p.x + p.y * 157.0;
     mix(
diff --git a/shaders/src/voxel_pac_man.rs b/shaders/src/voxel_pac_man.rs
@@ -75,7 +75,7 @@ const SQRT3: f32 = 1.73205080757;
 
 // PRNG (from https://www.shadertoy.com/view/4djSRW)
 fn rand(mut seed: Vec3) -> f32 {
-    seed = (seed * vec3(5.3983, 5.4427, 6.9371)).gl_fract();
+    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()
 }
@@ -170,13 +170,13 @@ impl State {
         let mut ray_step: f32 = 0.0;
         while ray_step < RAY_STEP_MAX {
             if ray_length < ray_length_in_voxel {
-                d.x = self.dist_voxel((*p + Vec3::splat(0.5)).gl_fract() - Vec3::splat(0.5));
+                d.x = self.dist_voxel((*p + Vec3::splat(0.5)).fract_gl() - Vec3::splat(0.5));
                 if d.x < DELTA {
                     break;
                 }
             } else if ray_length < ray_length_check_voxel {
                 let mut ray_delta: Vec3 = (Vec3::splat(0.5)
-                    - ray_sign * ((*p + Vec3::splat(0.5)).gl_fract() - Vec3::splat(0.5)))
+                    - ray_sign * ((*p + Vec3::splat(0.5)).fract_gl() - Vec3::splat(0.5)))
                     * ray_delta_voxel;
                 let d_next: f32 = ray_delta.x.min(ray_delta.y.min(ray_delta.z));
                 d = self.dist_scene((*p + Vec3::splat(0.5)).floor(), &mut p2);
@@ -214,7 +214,7 @@ impl State {
         let h: Vec2 = vec2(DELTA, -DELTA);
         let mut n: Vec3 = Vec3::ZERO;
         if voxelized > 0.5 {
-            p = (p + Vec3::splat(0.5)).gl_fract() - Vec3::splat(0.5);
+            p = (p + Vec3::splat(0.5)).fract_gl() - Vec3::splat(0.5);
             n = h.xxx() * self.dist_voxel(p + h.xxx())
                 + h.xyy() * self.dist_voxel(p + h.xyy())
                 + h.yxy() * self.dist_voxel(p + h.yxy())
@@ -245,7 +245,7 @@ fn hsv2rgb(mut hsv: Vec3) -> Vec3 {
         hsv.z
             * (Vec3::ONE
                 + Vec3::splat(hsv.y)
-                    * (((Vec3::splat(hsv.x) + vec3(0.0, 2.0 / 3.0, 1.0 / 3.0)).gl_fract() * 6.0
+                    * (((Vec3::splat(hsv.x) + vec3(0.0, 2.0 / 3.0, 1.0 / 3.0)).fract_gl() * 6.0
                         - Vec3::splat(3.0))
                     .abs()
                         - Vec3::splat(2.0))
diff --git a/shared/src/lib.rs b/shared/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -46,16 +46,16 @@ fn hash(n: f32) -> f32 {`
`46`	`46`	`(n.sin() * 43758.5453).gl_fract()`
`47`	`47`	`}`
`48`	`48`	`fn _hash2(n: f32) -> Vec2 {`
`49`		`- (vec2(n, n + 1.0).sin() * vec2(2.1459123, 3.3490423)).gl_fract()`
	`49`	`+ (vec2(n, n + 1.0).sin() * vec2(2.1459123, 3.3490423)).fract_gl()`
`50`	`50`	`}`
`51`	`51`	`fn hash2_vec(n: Vec2) -> Vec2 {`
`52`		`- (vec2(n.x * n.y, n.x + n.y).sin() * vec2(2.1459123, 3.3490423)).gl_fract()`
	`52`	`+ (vec2(n.x * n.y, n.x + n.y).sin() * vec2(2.1459123, 3.3490423)).fract_gl()`
`53`	`53`	`}`
`54`	`54`	`fn _hash3(n: f32) -> Vec3 {`
`55`		`- (vec3(n, n + 1.0, n + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).gl_fract()`
	`55`	`+ (vec3(n, n + 1.0, n + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).fract_gl()`
`56`	`56`	`}`
`57`	`57`	`fn hash3_vec(n: Vec2) -> Vec3 {`
`58`		`- (vec3(n.x, n.y, n.x + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).gl_fract()`
	`58`	`+ (vec3(n.x, n.y, n.x + 2.0).sin() * vec3(3.5453123, 4.1459123, 1.3490423)).fract_gl()`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`//`
Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ impl Inputs {`
`159`	`159`
`160`	`160`	`// drag your mouse to apply circle inversion`
`161`	`161`	`if ms.y != -2.0 && ms.w > -2.0 {`
`162`		`- uv = inversion(uv, (60.0.deg_to_radians()).cos());`
	`162`	`+ uv = inversion(uv, 60.0.to_radians().cos());`
`163`	`163`	`ci = ms.xy();`
`164`	`164`	`}`
`165`	`165`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ const M: Mat2 = mat2(vec2(1.6, 1.2), vec2(-1.2, 1.6));`
`27`	`27`
`28`	`28`	`fn hash(mut p: Vec2) -> Vec2 {`
`29`	`29`	`p = vec2(p.dot(vec2(127.1, 311.7)), p.dot(vec2(269.5, 183.3)));`
`30`		`- Vec2::splat(-1.0) + 2.0 * (p.sin() * 43758.5453123).gl_fract()`
	`30`	`+ Vec2::splat(-1.0) + 2.0 * (p.sin() * 43758.5453123).fract_gl()`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`fn noise(p: Vec2) -> f32 {`
Original file line number	Diff line number	Diff line change
`@@ -223,7 +223,7 @@ pub fn fs(constants: &ShaderConstants, mut frag_coord: Vec2) -> Vec4 {`
`223`	`223`	`.main_image(&mut color, frag_coord),`
`224`	`224`	`_ => {}`
`225`	`225`	`}`
`226`		`- pow(color.truncate(), 2.2).extend(color.w)`
	`226`	`+ Vec3::powf(color.truncate(), 2.2).extend(color.w)`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`#[allow(unused_attributes)]`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ fn _n2(x: f32, y: f32) -> f32 {`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`fn n3(mut p: Vec3) -> f32 {`
`97`		`- p = (p * 0.3183099 + Vec3::splat(0.1)).gl_fract();`
	`97`	`+ p = (p * 0.3183099 + Vec3::splat(0.1)).fract_gl();`
`98`	`98`	`p *= 17.0;`
`99`	`99`	`(p.x * p.y * p.z * (p.x + p.y + p.z)).gl_fract()`
`100`	`100`	`}`
`@@ -145,7 +145,7 @@ fn repeat(pos: Vec3, size: Vec3) -> Rc {`
`145`	`145`	`o.h = size * 0.5;`
`146`	`146`	`o.id = (pos / size).floor(); // used to give a unique id to each cell`
`147`	`147`
`148`		`- o.p = pos.rem_euclid_vec(size) - o.h;`
	`148`	`+ o.p = pos.rem_euclid(size) - o.h;`
`149`	`149`	`//o.c = o.id*size+o.h;`
`150`	`150`
`151`	`151`	`o`
`@@ -172,14 +172,14 @@ impl State {`
`172`	`172`
`173`	`173`	`// 3 out, 1 in... DAVE HOSKINS`
`174`	`174`	`fn n31(p: f32) -> Vec3 {`
`175`		`- let mut p3: Vec3 = (Vec3::splat(p) * vec3(0.1031, 0.11369, 0.13787)).gl_fract();`
	`175`	`+ let mut p3: Vec3 = (Vec3::splat(p) * vec3(0.1031, 0.11369, 0.13787)).fract_gl();`
`176`	`176`	`p3 += Vec3::splat(p3.dot(p3.yzx() + Vec3::splat(19.19)));`
`177`	`177`	`vec3(`
`178`	`178`	`(p3.x + p3.y) * p3.z,`
`179`	`179`	`(p3.x + p3.z) * p3.y,`
`180`	`180`	`(p3.y + p3.z) * p3.x,`
`181`	`181`	`)`
`182`		`- .gl_fract()`
	`182`	`+ .fract_gl()`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`// DE functions from IQ`