hash util in noise

Author: cieplypolar

packages/typegpu-noise/src/generator.ts

@@ -1,5 +1,6 @@
 import tgpu, { d, type TgpuFnShell, type TgpuSlot } from 'typegpu';
-import { bitcastU32toF32, cos, dot, fract } from 'typegpu/std';
+import { cos, dot, fract } from 'typegpu/std';
+import { hash, u32To01Float } from './utils.ts';
 
 export interface StatefulGenerator {
   seed?: (seed: number) => void;
@@ -49,36 +50,70 @@ export const BPETER: StatefulGenerator = (() => {
 })();
 
 /**
- * Naive Linear Congruential Generator (LCG)
+ * Incorporated from https://github.com/chaos-matters/chaos-master
+ * by deluksic and Komediruzecki
  */
-export const LCG: StatefulGenerator = (() => {
-  const seed = tgpu.privateVar(d.u32);
+export const XOROSHIRO64STARSTAR: StatefulGenerator = (() => {
+  const seed = tgpu.privateVar(d.vec2u);
+
+  const rotl = tgpu.fn(
+    [d.u32, d.u32],
+    d.u32,
+  )((x, k) => {
+    return (x << k) | (x >> (32 - k));
+  });
+
+  const next = tgpu.fn([])(() => {
+    const s0 = seed.$[0];
+    let s1 = seed.$[1];
 
-  const u32To01Float = tgpu.fn(
-    [d.u32],
-    d.f32,
-  )((value) => {
-    const mantissa = value >> 9;
-    const bits = 0x3f800000 | mantissa;
-    const f = bitcastU32toF32(bits);
-    return f - 1;
+    s1 ^= s0;
+    seed.$[0] = rotl(s0, 26) ^ s1 ^ (s1 << 9);
+    seed.$[1] = rotl(s1, 13);
   });
 
   return {
-    seed: tgpu.fn([d.f32])((value) => {
-      seed.$ = d.u32(value * 32768);
-    }),
-
     seed2: tgpu.fn([d.vec2f])((value) => {
-      seed.$ = d.u32(value.x * 32768 + value.y * 1024);
+      seed.$ = d.vec2u(value);
     }),
 
-    seed3: tgpu.fn([d.vec3f])((value) => {
-      seed.$ = d.u32(value.x * 32768 + value.y * 1024 + value.z * 32);
+    sample: randomGeneratorShell(() => {
+      'use gpu';
+      next();
+      const r = seed.$.x;
+      return u32To01Float(r);
+    }).$name('sample'),
+  };
+})();
+
+/**
+ * Naive Linear Congruential Generator (LCG) with 32 bits state
+ */
+export const LCG32: StatefulGenerator = (() => {
+  const seed = tgpu.privateVar(d.u32);
+
+  return {
+    seed: tgpu.fn([d.f32])((value) => {
+      seed.$ = hash(d.u32(value));
     }),
 
-    seed4: tgpu.fn([d.vec4f])((value) => {
-      seed.$ = d.u32(value.x * 32768 + value.y * 1024 + value.z * 32 + value.w);
+    sample: randomGeneratorShell(() => {
+      'use gpu';
+      seed.$ = seed.$ * 1664525 + 1013904223; // % 2 ^ 32
+      return u32To01Float(seed.$);
+    }).$name('sample'),
+  };
+})();
+
+/**
+ * Naive Linear Congruential Generator (LCG) with 64 bits state
+ */
+export const LCG64: StatefulGenerator = (() => {
+  const seed = tgpu.privateVar(d.u32);
+
+  return {
+    seed: tgpu.fn([d.f32])((value) => {
+      seed.$ = d.u32(value) * 1048577;
     }),
 
     sample: randomGeneratorShell(() => {

packages/typegpu-noise/src/index.ts

@@ -145,7 +145,9 @@ export {
   BPETER,
   // The default (Can change between releases to improve uniformity).
   DefaultGenerator,
-  LCG,
+  LCG32,
+  LCG64,
+  XOROSHIRO64STARSTAR,
   // ---
   randomGeneratorShell,
   randomGeneratorSlot,

packages/typegpu-noise/src/utils.ts

@@ -1,4 +1,4 @@
-import type { d } from 'typegpu';
+import tgpu, { d, std } from 'typegpu';
 
 export type Prettify<T> = {
   [K in keyof T]: T[K];
@@ -28,3 +28,36 @@ export function quinticDerivative(t: d.vecBase): d.vecBase {
   'use gpu';
   return 30 * t * t * (t * (t - 2) + 1);
 }
+
+/*
+ * Converts u32 to f32 value in the range [0.0, 1.0).
+ */
+export const u32To01Float = tgpu.fn(
+  [d.u32],
+  d.f32,
+)((value) => {
+  const mantissa = value >> 9;
+  const bits = 0x3f800000 | mantissa;
+  const f = std.bitcastU32toF32(bits);
+  return f - 1;
+});
+
+/**
+ * Simple hashing function to scramble the seed.
+ *
+ * Incorporated from https://github.com/chaos-matters/chaos-master
+ * by deluksic and Komediruzecki
+ */
+export const hash = tgpu.fn(
+  [d.u32],
+  d.u32,
+)((v) => {
+  let x = v ^ (v >> 17);
+  x *= d.u32(0xed5ad4bb);
+  x ^= x >> 11;
+  x *= d.u32(0xac4c1b51);
+  x ^= x >> 15;
+  x *= d.u32(0x31848bab);
+  x ^= x >> 14;
+  return x;
+});