starting docs update

Author: cieplypolar

apps/typegpu-docs/src/content/docs/ecosystem/typegpu-noise.mdx

@@ -99,6 +99,9 @@ const main = tgpu.fragmentFn({
 });
 ```
 
+### Available PRNGs
+
+
 :::tip
 Due to limited float precision, for large seeds the samples tend to repeat quickly. To avoid this, keep the seed in the range `[0, 1]`.
 :::
@@ -277,34 +280,33 @@ const f = tgpu.computeFn({ workgroupSize: [1] })(() => {
 });
 // ---cut---
 import {
+  hash,
+  randomGeneratorShell,
   randomGeneratorSlot,
+  u32To01F32,
   type StatefulGenerator,
 } from '@typegpu/noise';
 
-const LCG: StatefulGenerator = (() => {
+const LCG32: StatefulGenerator = (() => {
   const seed = tgpu.privateVar(d.u32);
 
-  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;
-  });
-
-  return {
-    seed2: (value: d.v2f) => {
-      'use gpu';
-      seed.$ = d.u32(value.x * std.pow(32, 3) + value.y * std.pow(32, 2));
-    },
-    sample: () => {
-      'use gpu';
-      seed.$ = seed.$ * 1664525 + 1013904223; // % 2 ^ 32
-      return u32To01Float(seed.$);
-    },
-  };
+ const multiplier = d.u32(1664525);
+ const increment = d.u32(1013904223);
+
+ return {
+   seed: tgpu.fn([d.f32])((value) => {
+     seed.$ = hash(d.u32(value));
+   }),
+
+   sample: randomGeneratorShell(() => {
+     'use gpu';
+     seed.$ = multiplier * seed.$ + increment; // % 2 ^ 32
+     return u32To01F32(seed.$);
+   }).$name('sample'),
+ };
 })();
 
 const pipeline = root
-  .with(randomGeneratorSlot, LCG)
+  .with(randomGeneratorSlot, LCG32)
   .createComputePipeline({ compute: f });
 ```

packages/typegpu-noise/src/utils.ts

@@ -28,7 +28,8 @@ export function quinticDerivative(t: d.vecBase): d.vecBase {
   'use gpu';
   return 30 * t * t * (t * (t - 2) + 1);
 }
-/*
+
+/**
  * Left circular shif of x by k positions.
  */
 export const rotl = tgpu.fn(
@@ -38,8 +39,8 @@ export const rotl = tgpu.fn(
   return (x << k) | (x >> (32 - k));
 });
 
-/*
- * Converts u32 to f32 value in the range [0.0, 1.0).
+/**
+ * Converts `u32` to `f32` value in the range `[0.0, 1.0)`.
  */
 export const u32To01F32 = tgpu.fn(
   [d.u32],
@@ -61,8 +62,8 @@ export const u32To01F32 = tgpu.fn(
 export const hash = tgpu.fn(
   [d.u32],
   d.u32,
-)((v) => {
-  let x = v ^ (v >> 17);
+)((value) => {
+  let x = value ^ (value >> 17);
   x *= d.u32(0xed5ad4bb);
   x ^= x >> 11;
   x *= d.u32(0xac4c1b51);
@@ -73,8 +74,8 @@ export const hash = tgpu.fn(
 });
 
 /**
- * Emulated 64-bit unsigned addition on two vec2u values.
- * Each vec2u represents a u64: x = low 32 bits, y = high 32 bits.
+ * Emulated 64-bit unsigned addition on two `vec2u` values.
+ * Each `vec2u` represents a `u64`: x = low 32 bits, y = high 32 bits.
  */
 export const u64Add = tgpu.fn(
   [d.vec2u, d.vec2u],
@@ -87,8 +88,8 @@ export const u64Add = tgpu.fn(
 });
 
 /**
- * Emulated 64-bit unsigned multiplication on two vec2u values.
- * Each vec2u represents a u64: x = low 32 bits, y = high 32 bits.
+ * Emulated 64-bit unsigned multiplication on two `vec2u` values.
+ * Each `vec2u` represents a `u64`: x = low 32 bits, y = high 32 bits.
  */
 export const u64Mul = tgpu.fn(
   [d.vec2u, d.vec2u],