@matboks/utilities 0.0.1 → 0.0.18

package/dist/shader-modules/modules/random.d.ts

@@ -1 +1 @@
-export declare const randomDefinition = "\nimport { TWO_PI, PI } from \"@/constants\";\n\nexport { \n  random, random2, random3,\n  randomGauss,\n  randomUnit\n };\n\nuint hash(uint value) {\n  value ^= value >> 16;\n  value *= 569420461u;\n  value ^= value >> 15;\n  value *= 3545902487u;\n  value ^= value >> 15;\n  return value;\n}\n\nuint hash(uvec2 v) {\n  return hash(v.x ^ hash(v.y));\n}\n\nuint hash(uvec3 v) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z)));\n}\n\nuint hash(uvec4 v) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w))));\n}\n\nuint hash(uvec4 v, uint u) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w ^ hash(u)))));\n}\n\nfloat hashToFloat(uint u) {\n  uint mant = 8388607u;\n  uint one = 1065353216u;\n\n  u &= mant;\n  u |= one;\n\n  float f = uintBitsToFloat(u);\n  return f - 1.0;\n}\n\nfloat random(float p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec2 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec3 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec4 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(float p, float seed) {\n  return random(vec2(p, seed));\n}\n\nfloat random(vec2 p, float seed) {\n  return random(vec3(p, seed));\n}\n\nfloat random(vec3 p, float seed) {\n  return random(vec4(p, seed));\n}\n\nfloat random(vec4 p, float seed) {\n  return hashToFloat(hash(floatBitsToUint(p), floatBitsToUint(seed)));\n}\n\nvec2 random2(float p, float seed) {\n  return vec2(random(vec3(p, seed, 0), random(vec3(p, seed, 1))));\n}\n\nvec2 random2(float p) {\n  return random2(p, 0.);\n}\n\nvec2 random2(vec2 p, float seed) {\n  return vec2(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)));\n}\n\nvec2 random2(vec2 p) {\n  return random2(p, 0.0);\n}\n\nvec2 random2(vec3 p, float seed) {\n  return vec2(random(vec4(p, seed), 0.), random(vec4(p, seed), 1.));\n}\n\nvec2 random2(vec3 p) {\n  return random2(p, 0.0);\n}\n\nvec3 random3(float p, float seed) {\n  return vec3(\n    random(vec3(p, seed, 0)), \n    random(vec3(p, seed, 1)), \n    random(vec3(p, seed, 2))\n  );\n}\n\nvec3 random3(float p) {\n  return random3(p, 0.0);\n}\n\nvec3 random3(vec2 p, float seed) {\n  return vec3(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)), random(vec4(p, seed, 2)));\n}\n\nvec3 random3(vec2 p) {\n  return random3(p, 0.0);\n}\n\nvec3 random3(vec3 p, float seed) {\n  return vec3(random(vec4(p, seed), 0.0), random(vec4(p, seed), 1.0), random(vec4(p, seed), 2.0));\n}\n\nfloat randomGaussian(vec3 p, float seed) {\n  float u1 = random(vec4(p, 1), seed);\n  float u2 = random(vec4(p, 2), seed);\n  return sqrt(-2.0 * log(u1)) * cos(TWO_PI * u2);\n}\n\nvec2 randomUnit(vec2 p, float seed) {\n  float direction = TWO_PI*random(p, seed);\n  return vec2(cos(direction), sin(direction));\n}\n\nvec3 randomUnit(vec3 p, float seed) {\n  return normalize(vec3(\n    randomGaussian(p, seed),\n    randomGaussian(p, random(seed, 1.)),\n    randomGaussian(p, random(seed, 2.))\n  ));\n}\n\n\n\n";
+export declare const randomDefinition = "\nimport { TWO_PI, PI } from \"@/constants\";\n\nexport { \n  random, random2, random3, random4,\n  randomUnit\n };\n\nconst float SEED_OFFSET = 2123.1415926535897932384626433832795;\n\nuint hash(uint x) {\n  x += 2127912214u;\n  x ^= x >> 15;\n  x *= 3545902487u;\n  return x;\n}\n\nuint hash(uvec2 v) {\n  return hash(v.x ^ hash(v.y));\n}\n\nuint hash(uvec3 v) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z)));\n}\n\nuint hash(uvec4 v) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w))));\n}\n\nuint hash(uvec4 v, uint u) {\n  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w ^ hash(u)))));\n}\n\nfloat hashToFloat(uint u) {\n  uint mant = 8388607u;\n  uint one = 1065353216u;\n\n  u &= mant;\n  u |= one;\n\n  float f = uintBitsToFloat(u);\n  return f - 1.0;\n}\n\nfloat random(float p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec2 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec3 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(vec4 p) {\n  return hashToFloat(hash(floatBitsToUint(p)));\n}\n\nfloat random(float p, float seed) {\n  return random(vec2(p, seed));\n}\n\nfloat random(vec2 p, float seed) {\n  return random(vec3(p, seed));\n}\n\nfloat random(vec3 p, float seed) {\n  return random(vec4(p, seed));\n}\n\nfloat random(vec4 p, float seed) {\n  return hashToFloat(hash(floatBitsToUint(p), floatBitsToUint(seed)));\n}\n\nvec2 random2(float p, float seed) {\n  return vec2(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec2 random2(float p) {\n  return random2(p, 0.);\n}\n\nvec2 random2(vec2 p, float seed) {\n  return vec2(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec2 random2(vec2 p) {\n  return random2(p, 0.0);\n}\n\nvec2 random2(vec3 p, float seed) {\n  return vec2(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec2 random2(vec3 p) {\n  return random2(p, 0.0);\n}\n\nvec3 random3(float p, float seed) {\n  return vec3(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec3 random3(float p) {\n  return random3(p, 0.0);\n}\n\nvec3 random3(vec2 p, float seed) {\n  return vec3(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec3 random3(vec2 p) {\n  return random3(p, 0.0);\n}\n\nvec3 random3(vec3 p, float seed) {\n  return vec3(\n    random(p, seed), \n    random(p, seed += SEED_OFFSET), \n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec4 random4(vec4 p, float seed) {\n  return vec4(\n    random(p, seed),\n    random(p, seed += SEED_OFFSET),\n    random(p, seed += SEED_OFFSET),\n    random(p, seed += SEED_OFFSET)\n  );\n}\n\nvec4 random4(vec4 p) {\n  return random4(p, 0.0);\n}\n\nvec2 randomUnit(vec2 p, float seed) {\n  float direction = TWO_PI*random(p, seed);\n  return vec2(cos(direction), sin(direction));\n}\n\nvec3 randomUnit(vec3 p, float seed) {\n  float z = -1.0 + 2.0*random(p, seed);\n  float theta = TWO_PI*random(p, seed += SEED_OFFSET);\n  float r = sqrt(1.0 - z*z);\n  return vec3(\n    r*cos(theta),\n    r*sin(theta),\n    z\n  );\n}\n\nvec4 randomUnit(vec4 p, float seed) {\n  float a1 = TWO_PI*random(p, seed);\n  float a2 = TWO_PI*random(p, seed += SEED_OFFSET);\n  float u = random(p, seed += SEED_OFFSET);\n  float r1 = sqrt(u);        \n  float r2 = sqrt(1.0 - u);\n\n  return vec4(\n    cos(a1) * r1,\n    sin(a1) * r1, \n    cos(a2) * r2, \n    sin(a2) * r2\n  );\n}\n\n";

package/dist/shader-modules/modules/random.js

@@ -1,147 +1,186 @@
-export const randomDefinition = /*glsl*/ `
-import { TWO_PI, PI } from "@/constants";
-
-export { 
-  random, random2, random3,
-  randomGauss,
-  randomUnit
- };
-
-uint hash(uint value) {
-  value ^= value >> 16;
-  value *= 569420461u;
-  value ^= value >> 15;
-  value *= 3545902487u;
-  value ^= value >> 15;
-  return value;
-}
-
-uint hash(uvec2 v) {
-  return hash(v.x ^ hash(v.y));
-}
-
-uint hash(uvec3 v) {
-  return hash(v.x ^ hash(v.y ^ hash(v.z)));
-}
-
-uint hash(uvec4 v) {
-  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w))));
-}
-
-uint hash(uvec4 v, uint u) {
-  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w ^ hash(u)))));
-}
-
-float hashToFloat(uint u) {
-  uint mant = 8388607u;
-  uint one = 1065353216u;
-
-  u &= mant;
-  u |= one;
-
-  float f = uintBitsToFloat(u);
-  return f - 1.0;
-}
-
-float random(float p) {
-  return hashToFloat(hash(floatBitsToUint(p)));
-}
-
-float random(vec2 p) {
-  return hashToFloat(hash(floatBitsToUint(p)));
-}
-
-float random(vec3 p) {
-  return hashToFloat(hash(floatBitsToUint(p)));
-}
-
-float random(vec4 p) {
-  return hashToFloat(hash(floatBitsToUint(p)));
-}
-
-float random(float p, float seed) {
-  return random(vec2(p, seed));
-}
-
-float random(vec2 p, float seed) {
-  return random(vec3(p, seed));
-}
-
-float random(vec3 p, float seed) {
-  return random(vec4(p, seed));
-}
-
-float random(vec4 p, float seed) {
-  return hashToFloat(hash(floatBitsToUint(p), floatBitsToUint(seed)));
-}
-
-vec2 random2(float p, float seed) {
-  return vec2(random(vec3(p, seed, 0), random(vec3(p, seed, 1))));
-}
-
-vec2 random2(float p) {
-  return random2(p, 0.);
-}
-
-vec2 random2(vec2 p, float seed) {
-  return vec2(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)));
-}
-
-vec2 random2(vec2 p) {
-  return random2(p, 0.0);
-}
-
-vec2 random2(vec3 p, float seed) {
-  return vec2(random(vec4(p, seed), 0.), random(vec4(p, seed), 1.));
-}
-
-vec2 random2(vec3 p) {
-  return random2(p, 0.0);
-}
-
-vec3 random3(float p, float seed) {
-  return vec3(
-    random(vec3(p, seed, 0)), 
-    random(vec3(p, seed, 1)), 
-    random(vec3(p, seed, 2))
-  );
-}
-
-vec3 random3(float p) {
-  return random3(p, 0.0);
-}
-
-vec3 random3(vec2 p, float seed) {
-  return vec3(random(vec4(p, seed, 0)), random(vec4(p, seed, 1)), random(vec4(p, seed, 2)));
-}
-
-vec3 random3(vec2 p) {
-  return random3(p, 0.0);
-}
-
-vec3 random3(vec3 p, float seed) {
-  return vec3(random(vec4(p, seed), 0.0), random(vec4(p, seed), 1.0), random(vec4(p, seed), 2.0));
-}
-
-float randomGaussian(vec3 p, float seed) {
-  float u1 = random(vec4(p, 1), seed);
-  float u2 = random(vec4(p, 2), seed);
-  return sqrt(-2.0 * log(u1)) * cos(TWO_PI * u2);
-}
-
-vec2 randomUnit(vec2 p, float seed) {
-  float direction = TWO_PI*random(p, seed);
-  return vec2(cos(direction), sin(direction));
-}
-
-vec3 randomUnit(vec3 p, float seed) {
-  return normalize(vec3(
-    randomGaussian(p, seed),
-    randomGaussian(p, random(seed, 1.)),
-    randomGaussian(p, random(seed, 2.))
-  ));
-}
-
-
-
+export const randomDefinition = /*glsl*/ `
+import { TWO_PI, PI } from "@/constants";
+
+export { 
+  random, random2, random3, random4,
+  randomUnit
+ };
+
+const float SEED_OFFSET = 2123.1415926535897932384626433832795;
+
+uint hash(uint x) {
+  x += 2127912214u;
+  x ^= x >> 15;
+  x *= 3545902487u;
+  return x;
+}
+
+uint hash(uvec2 v) {
+  return hash(v.x ^ hash(v.y));
+}
+
+uint hash(uvec3 v) {
+  return hash(v.x ^ hash(v.y ^ hash(v.z)));
+}
+
+uint hash(uvec4 v) {
+  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w))));
+}
+
+uint hash(uvec4 v, uint u) {
+  return hash(v.x ^ hash(v.y ^ hash(v.z ^ hash(v.w ^ hash(u)))));
+}
+
+float hashToFloat(uint u) {
+  uint mant = 8388607u;
+  uint one = 1065353216u;
+
+  u &= mant;
+  u |= one;
+
+  float f = uintBitsToFloat(u);
+  return f - 1.0;
+}
+
+float random(float p) {
+  return hashToFloat(hash(floatBitsToUint(p)));
+}
+
+float random(vec2 p) {
+  return hashToFloat(hash(floatBitsToUint(p)));
+}
+
+float random(vec3 p) {
+  return hashToFloat(hash(floatBitsToUint(p)));
+}
+
+float random(vec4 p) {
+  return hashToFloat(hash(floatBitsToUint(p)));
+}
+
+float random(float p, float seed) {
+  return random(vec2(p, seed));
+}
+
+float random(vec2 p, float seed) {
+  return random(vec3(p, seed));
+}
+
+float random(vec3 p, float seed) {
+  return random(vec4(p, seed));
+}
+
+float random(vec4 p, float seed) {
+  return hashToFloat(hash(floatBitsToUint(p), floatBitsToUint(seed)));
+}
+
+vec2 random2(float p, float seed) {
+  return vec2(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET)
+  );
+}
+
+vec2 random2(float p) {
+  return random2(p, 0.);
+}
+
+vec2 random2(vec2 p, float seed) {
+  return vec2(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET)
+  );
+}
+
+vec2 random2(vec2 p) {
+  return random2(p, 0.0);
+}
+
+vec2 random2(vec3 p, float seed) {
+  return vec2(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET)
+  );
+}
+
+vec2 random2(vec3 p) {
+  return random2(p, 0.0);
+}
+
+vec3 random3(float p, float seed) {
+  return vec3(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET), 
+    random(p, seed += SEED_OFFSET)
+  );
+}
+
+vec3 random3(float p) {
+  return random3(p, 0.0);
+}
+
+vec3 random3(vec2 p, float seed) {
+  return vec3(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET), 
+    random(p, seed += SEED_OFFSET)
+  );
+}
+
+vec3 random3(vec2 p) {
+  return random3(p, 0.0);
+}
+
+vec3 random3(vec3 p, float seed) {
+  return vec3(
+    random(p, seed), 
+    random(p, seed += SEED_OFFSET), 
+    random(p, seed += SEED_OFFSET)
+  );
+}
+
+vec4 random4(vec4 p, float seed) {
+  return vec4(
+    random(p, seed),
+    random(p, seed += SEED_OFFSET),
+    random(p, seed += SEED_OFFSET),
+    random(p, seed += SEED_OFFSET)
+  );
+}
+
+vec4 random4(vec4 p) {
+  return random4(p, 0.0);
+}
+
+vec2 randomUnit(vec2 p, float seed) {
+  float direction = TWO_PI*random(p, seed);
+  return vec2(cos(direction), sin(direction));
+}
+
+vec3 randomUnit(vec3 p, float seed) {
+  float z = -1.0 + 2.0*random(p, seed);
+  float theta = TWO_PI*random(p, seed += SEED_OFFSET);
+  float r = sqrt(1.0 - z*z);
+  return vec3(
+    r*cos(theta),
+    r*sin(theta),
+    z
+  );
+}
+
+vec4 randomUnit(vec4 p, float seed) {
+  float a1 = TWO_PI*random(p, seed);
+  float a2 = TWO_PI*random(p, seed += SEED_OFFSET);
+  float u = random(p, seed += SEED_OFFSET);
+  float r1 = sqrt(u);        
+  float r2 = sqrt(1.0 - u);
+
+  return vec4(
+    cos(a1) * r1,
+    sin(a1) * r1, 
+    cos(a2) * r2, 
+    sin(a2) * r2
+  );
+}
+
 `;

package/dist/shader-modules/modules/ray-marching.js

@@ -1,54 +1,54 @@
-export const rayMarchingDefinition = /*glsl*/ `
-
-export {
-  rayMarch,
-  Ray, RayMarchResult
-}
-
-struct Ray {
-  vec3 origin;
-  vec3 direction;
-};
-
-struct RayMarchResult {
-  vec3 position;
-  vec3 partialPosition;
-  float minimumDistance;
-  bool hit;
-};
-
-RayMarchResult rayMarch(Ray ray, float minThreshold, float maxThreshold, int partialIterations, float maxIterations, float sdf(vec3)) {
-  vec3 position;
-  float t = 0.0;
-
-  vec3 origin = ray.origin;
-  vec3 direction = ray.direction;
-  
-  vec3 partialPosition;
-  float minimumDistance = 1e20;
-  bool hit = false;
-
-  int n = int(maxIterations) + 1;
-  for (int i = 0; i <= n; i++) {
-    position = origin + direction*t;
-    float d = sdf(position);
-
-    if (i == partialIterations) partialPosition = position;
-
-    t += d*min(1.0, maxIterations - float(i));
-    minimumDistance = min(minimumDistance, d);
-
-    if (abs(d) < minThreshold) {
-      hit = true;
-      break;
-    } 
-    
-    if (d > maxThreshold) {
-      break;
-    }
-  }
-  
-  return RayMarchResult(position, partialPosition, minimumDistance, hit);
-}
-
+export const rayMarchingDefinition = /*glsl*/ `
+
+export {
+  rayMarch,
+  Ray, RayMarchResult
+}
+
+struct Ray {
+  vec3 origin;
+  vec3 direction;
+};
+
+struct RayMarchResult {
+  vec3 position;
+  vec3 partialPosition;
+  float minimumDistance;
+  bool hit;
+};
+
+RayMarchResult rayMarch(Ray ray, float minThreshold, float maxThreshold, int partialIterations, float maxIterations, float sdf(vec3)) {
+  vec3 position;
+  float t = 0.0;
+
+  vec3 origin = ray.origin;
+  vec3 direction = ray.direction;
+  
+  vec3 partialPosition;
+  float minimumDistance = 1e20;
+  bool hit = false;
+
+  int n = int(maxIterations) + 1;
+  for (int i = 0; i <= n; i++) {
+    position = origin + direction*t;
+    float d = sdf(position);
+
+    if (i == partialIterations) partialPosition = position;
+
+    t += d*min(1.0, maxIterations - float(i));
+    minimumDistance = min(minimumDistance, d);
+
+    if (abs(d) < minThreshold) {
+      hit = true;
+      break;
+    } 
+    
+    if (d > maxThreshold) {
+      break;
+    }
+  }
+  
+  return RayMarchResult(position, partialPosition, minimumDistance, hit);
+}
+
 `;