@matboks/utilities - npm Package Compare versions

Comparing version 0.0.1 to 0.0.2

dist/constants 2.js

+export const EPS = 1e-9;

dist/constants 3.js

+export const EPS = 1e-9;

dist/constants.d 2.ts

+export declare const EPS = 1e-9;

dist/constants.d 3.ts

+export declare const EPS = 1e-9;

dist/index 2.js

+export * from "./geometry/index.js";
+export * from "./math/index.js";
+export * from "./utilities/index.js";
+export * from "./noise/index.js";
+export * from "./constants.js";
+export * from "./tilings/index.js";
+export * from "./transformations/index.js";
+export * from "./types.js";
+export * from "./shader-renderer/index.js";
+export * from "./shader-modules/index.js";
+export * from "./constants.js";

dist/index 3.js

+export * from "./geometry/index.js";
+export * from "./math/index.js";
+export * from "./utilities/index.js";
+export * from "./noise/index.js";
+export * from "./constants.js";
+export * from "./tilings/index.js";
+export * from "./transforms/index.js";
+export * from "./types.js";
+export * from "./shader-renderer/index.js";
+export * from "./shader-modules/index.js";
+export * from "./constants.js";

dist/index.d 2.ts

+export * from "./geometry/index.js";
+export * from "./math/index.js";
+export * from "./utilities/index.js";
+export * from "./noise/index.js";
+export * from "./constants.js";
+export * from "./tilings/index.js";
+export * from "./transformations/index.js";
+export * from "./types.js";
+export * from "./shader-renderer/index.js";
+export * from "./shader-modules/index.js";
+export * from "./constants.js";

dist/index.d 3.ts

+export * from "./geometry/index.js";
+export * from "./math/index.js";
+export * from "./utilities/index.js";
+export * from "./noise/index.js";
+export * from "./constants.js";
+export * from "./tilings/index.js";
+export * from "./transforms/index.js";
+export * from "./types.js";
+export * from "./shader-renderer/index.js";
+export * from "./shader-modules/index.js";
+export * from "./constants.js";

dist/shader-modules/modules/sdf.d.ts

+export declare const sdfDefinition = "\n\nimport { barycentric, transformToZAxis } from \"@/geometry\";\nimport { lerp, signed } from \"@/utils\";\n\nexport {\n  sphere, box, rectangularCylinder, \n  discoBall, polygon, donut, boxFrame,\n  triangleSDFSquared, meshSDF, sdfNormal\n}\n\nfloat sphere(vec3 p, vec3 center, float radius) {\n  return length(p - center) - radius;\n}\n\nfloat box(vec3 p, vec3 center, vec3 direction, vec3 size) {\n  p = transformToZAxis(p, center, direction, 0.0);\n  p = abs(p) - size/2.0;\n\n  // First part gives distance inside box, second part outside\n  return min(max(max(p.x, p.y), p.z), 0.0) + length(max(p, vec3(0)));\n}\n\nfloat rectangularCylinder(vec3 p, vec3 center, vec3 direction, vec2 size, float height, bool offsetCenter, float rotation) {\n  if (offsetCenter) center += 0.5*height*normalize(direction);\n  p = transformToZAxis(p, center, direction, rotation);\n  return box(p, vec3(0), vec3(0, 0, 1), vec3(size, height));\n}\n\nfloat discoBall(vec3 p, vec3 center, float radius, float n, float o) {\n  p -= center;\n  float phi = -PI + 2.0*PI*(round(lerp(atan(p.y, p.x), -PI, PI)*n)/n + o);\n  float theta = PI*(round(lerp(acos(p.z/length(p)), 0.0, PI)*n)/n + o);\n\n  vec3 bp = vec3(sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta));\n\n  return dot(bp, p - radius*bp);\n}\n\nfloat discoBall(vec3 p, vec3 center, float radius, float n) {\n  return discoBall(p, center, radius, n, 0.0);\n}\n\nfloat polygon(vec2 p, float radius, float n) {\n  float theta = PI*signed((floor(lerp(atan(p.y, p.x), -PI, PI)*n) + .5)/n);\n  vec2 pp = vec2(cos(theta), sin(theta));\n  return dot(pp, p - radius*pp);\n}\n\nfloat donut(vec3 p, vec3 center, vec3 direction, float innerRadius, float outerRadius, float rotation, float sections, float sides) {\n  p = transformToZAxis(p, center, direction, 0.0);\n\n  vec3 xy = normalize(vec3(p.xy, 0));\n  float angle = mod(atan(xy.y, xy.x), 2.*PI);\n\n  angle = 2.*PI*round(sections*angle/(2.*PI))/sections;\n  innerRadius *= sqrt(PI/(sections*tan(PI/sections)));\n  outerRadius *= sqrt(PI/(sides*tan(PI/sides)));\n  return polygon(rotate(vec2(dot(p, vec3(cos(angle), sin(angle), 0)) - innerRadius, p.z), rotation + PI/4.), outerRadius, sides);\n}\n\nfloat boxFrame(vec3 p, vec3 center, vec3 direction, vec3 size, float thickness) {\n  float dBox = box(p, center, direction, size);\n\n  p = transformToZAxis(p, center, direction, 0.0);\n\n  vec3 o = 2.0*vec3(thickness, thickness, -1e9);\n  float dX = box(p, vec3(0), vec3(1, 0, 0), size.yzx - o);\n  float dY = box(p, vec3(0), vec3(0, 1, 0), size.zxy - o);\n  float dZ = box(p, vec3(0), vec3(0, 0, 1), size.xyz - o);\n\n  float dInner = min(dX, min(dY, dZ));\n  return max(dBox, -dInner);\n}\n\n// x is distance squared, y indicates which side of triangle p is on \n// (relative to normal: positive if p is above, negative if below)\nvec2 triangleSDFSquared(vec3 p, vec3 a, vec3 b, vec3 c) {\n  vec3 ab = b - a;\n  vec3 ca = a - c;\n  vec3 bc = c - b;\n\n  vec3 ap = p - a;\n  vec3 bp = p - b;\n  vec3 cp = p - c;\n\n  vec3 normal = cross(ab, -ca); // Negate to make cross(ab, ac), follows right-hand rule assuming abc is CCW\n  \n  bool isInsideTriangle = all(greaterThan(barycentric(p, a, b, c), vec3(0)));\n  \n  float dot2 = (vec3 v) => dot(v, v);  \n\n  bool isInsideXYProjection = all(greaterThan(barycentric(p.xy, a.xy, b.xy, c.xy), vec3(0)));\n\n  float distSquared;\n  bool isAboveXYProjection;\n\n  // If p is above XY projection, then dist = dot(ap, normal) > 0 when normal points upwards\n  // and dist < 0 when it points downwards. sign(normal.z)*dist > 0.0 then tells us if p is above \n  if (isInsideTriangle) {\n    float dist = dot(ap, normalize(normal));\n    distSquared = dist*dist;\n    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dist > 0.0;\n  } else {\n    distSquared = min(min(\n      dot2(ap - ab*clamp(dot(ap, ab) / dot2(ab), 0.0, 1.0)),\n      dot2(bp - bc*clamp(dot(bp, bc) / dot2(bc), 0.0, 1.0))),\n      dot2(cp - ca*clamp(dot(cp, ca) / dot2(ca), 0.0, 1.0))\n    );\n    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dot(ap, normal) > 0.0;\n  }\n\n  return vec2(distSquared, isAboveXYProjection ? -1.0 : 1.0);\n}\n\nvec3 sdfNormal(vec3 p, float sdf(vec3), float h) {\n  vec2 o = vec2(1, -1)*h;\n  return normalize( \n    o.xyy*sdf(p + o.xyy) +                     \n    o.yyx*sdf(p + o.yyx) + \n    o.yxy*sdf(p + o.yxy) + \n    o.xxx*sdf(p + o.xxx)\n  );\n}\n\n";

dist/shader-modules/modules/sdf.js

+export const sdfDefinition = /*glsl*/ `
+
+import { barycentric, transformToZAxis } from "@/geometry";
+import { lerp, signed } from "@/utils";
+
+export {
+  sphere, box, rectangularCylinder, 
+  discoBall, polygon, donut, boxFrame,
+  triangleSDFSquared, meshSDF, sdfNormal
+}
+
+float sphere(vec3 p, vec3 center, float radius) {
+  return length(p - center) - radius;
+}
+
+float box(vec3 p, vec3 center, vec3 direction, vec3 size) {
+  p = transformToZAxis(p, center, direction, 0.0);
+  p = abs(p) - size/2.0;
+
+  // First part gives distance inside box, second part outside
+  return min(max(max(p.x, p.y), p.z), 0.0) + length(max(p, vec3(0)));
+}
+
+float rectangularCylinder(vec3 p, vec3 center, vec3 direction, vec2 size, float height, bool offsetCenter, float rotation) {
+  if (offsetCenter) center += 0.5*height*normalize(direction);
+  p = transformToZAxis(p, center, direction, rotation);
+  return box(p, vec3(0), vec3(0, 0, 1), vec3(size, height));
+}
+
+float discoBall(vec3 p, vec3 center, float radius, float n, float o) {
+  p -= center;
+  float phi = -PI + 2.0*PI*(round(lerp(atan(p.y, p.x), -PI, PI)*n)/n + o);
+  float theta = PI*(round(lerp(acos(p.z/length(p)), 0.0, PI)*n)/n + o);
+
+  vec3 bp = vec3(sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta));
+
+  return dot(bp, p - radius*bp);
+}
+
+float discoBall(vec3 p, vec3 center, float radius, float n) {
+  return discoBall(p, center, radius, n, 0.0);
+}
+
+float polygon(vec2 p, float radius, float n) {
+  float theta = PI*signed((floor(lerp(atan(p.y, p.x), -PI, PI)*n) + .5)/n);
+  vec2 pp = vec2(cos(theta), sin(theta));
+  return dot(pp, p - radius*pp);
+}
+
+float donut(vec3 p, vec3 center, vec3 direction, float innerRadius, float outerRadius, float rotation, float sections, float sides) {
+  p = transformToZAxis(p, center, direction, 0.0);
+
+  vec3 xy = normalize(vec3(p.xy, 0));
+  float angle = mod(atan(xy.y, xy.x), 2.*PI);
+
+  angle = 2.*PI*round(sections*angle/(2.*PI))/sections;
+  innerRadius *= sqrt(PI/(sections*tan(PI/sections)));
+  outerRadius *= sqrt(PI/(sides*tan(PI/sides)));
+  return polygon(rotate(vec2(dot(p, vec3(cos(angle), sin(angle), 0)) - innerRadius, p.z), rotation + PI/4.), outerRadius, sides);
+}
+
+float boxFrame(vec3 p, vec3 center, vec3 direction, vec3 size, float thickness) {
+  float dBox = box(p, center, direction, size);
+
+  p = transformToZAxis(p, center, direction, 0.0);
+
+  vec3 o = 2.0*vec3(thickness, thickness, -1e9);
+  float dX = box(p, vec3(0), vec3(1, 0, 0), size.yzx - o);
+  float dY = box(p, vec3(0), vec3(0, 1, 0), size.zxy - o);
+  float dZ = box(p, vec3(0), vec3(0, 0, 1), size.xyz - o);
+
+  float dInner = min(dX, min(dY, dZ));
+  return max(dBox, -dInner);
+}
+
+// x is distance squared, y indicates which side of triangle p is on 
+// (relative to normal: positive if p is above, negative if below)
+vec2 triangleSDFSquared(vec3 p, vec3 a, vec3 b, vec3 c) {
+  vec3 ab = b - a;
+  vec3 ca = a - c;
+  vec3 bc = c - b;
+
+  vec3 ap = p - a;
+  vec3 bp = p - b;
+  vec3 cp = p - c;
+
+  vec3 normal = cross(ab, -ca); // Negate to make cross(ab, ac), follows right-hand rule assuming abc is CCW
+  
+  bool isInsideTriangle = all(greaterThan(barycentric(p, a, b, c), vec3(0)));
+  
+  float dot2 = (vec3 v) => dot(v, v);  
+
+  bool isInsideXYProjection = all(greaterThan(barycentric(p.xy, a.xy, b.xy, c.xy), vec3(0)));
+
+  float distSquared;
+  bool isAboveXYProjection;
+
+  // If p is above XY projection, then dist = dot(ap, normal) > 0 when normal points upwards
+  // and dist < 0 when it points downwards. sign(normal.z)*dist > 0.0 then tells us if p is above 
+  if (isInsideTriangle) {
+    float dist = dot(ap, normalize(normal));
+    distSquared = dist*dist;
+    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dist > 0.0;
+  } else {
+    distSquared = min(min(
+      dot2(ap - ab*clamp(dot(ap, ab) / dot2(ab), 0.0, 1.0)),
+      dot2(bp - bc*clamp(dot(bp, bc) / dot2(bc), 0.0, 1.0))),
+      dot2(cp - ca*clamp(dot(cp, ca) / dot2(ca), 0.0, 1.0))
+    );
+    isAboveXYProjection = isInsideXYProjection && sign(normal.z)*dot(ap, normal) > 0.0;
+  }
+
+  return vec2(distSquared, isAboveXYProjection ? -1.0 : 1.0);
+}
+
+vec3 sdfNormal(vec3 p, float sdf(vec3), float h) {
+  vec2 o = vec2(1, -1)*h;
+  return normalize( 
+    o.xyy*sdf(p + o.xyy) +                     
+    o.yyx*sdf(p + o.yyx) + 
+    o.yxy*sdf(p + o.yxy) + 
+    o.xxx*sdf(p + o.xxx)
+  );
+}
+
+`;

dist/tilings/tiler.d.ts

+export {};

dist/tilings/tiler.js

+// abstract class Tiler {
+export {};
+//   abstract tileSingleShape(shape: )
+// } 

dist/types 2.js

+export {};

dist/types 3.js

+export {};

dist/types.d 2.ts

+export {};

dist/types.d 3.ts

+export {};

dist/shader-modules/modules/noise.d.ts

@@ -1,1 +0,1 @@
-export declare const noiseDefinition = "\nimport { random, random2, random3, randomUnit } from \"@/random\";\nimport { triangleWave, dot2 } from \"@/utils\";\nimport { rotate, axisAngle } from \"@/geometry\";\nimport { PI } from \"@/constants\";\n\nexport {\n  valueNoise, perlinNoise, worleyNoise, voroNoise, gaboroNoise, \n  octaveNoise1D, octaveNoise2D, octaveNoise3D\n}\n\nfloat valueNoise(float p, float scale, float seed) {\n  p *= scale;\n\n  float pi = floor(p);\n  float pf = fract(p);\n\n  float sf = smoothstep(0.0, 1.0, pf);\n\n  return mix(random(pi, seed), random(pi + 1.0, seed), sf);\n}\n\nfloat valueNoise(vec2 p, float scale, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  vec2 pf = fract(p);\n\n  vec2 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  return mix(\n    mix(random(pi, seed), random(pi + o.xy, seed), sf.x),\n    mix(random(pi + o.yx, seed), random(pi + o.xx, seed), sf.x),\n    sf.y\n  );\n}\n\nfloat valueNoise(vec3 p, float scale, float seed) {\n  p *= scale;\n\n  vec3 pi = floor(p);\n  vec3 pf = fract(p);\n\n  vec3 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  return mix(\n    mix(\n      mix(random(pi, seed), random(pi + o.xyy, seed), sf.x),\n      mix(random(pi + o.yxy, seed), random(pi + o.xxy, seed), sf.x),\n      sf.y\n    ),\n    mix(\n      mix(random(pi + o.yyx, seed), random(pi + o.xyx, seed), sf.x),\n      mix(random(pi + o.yxx, seed), random(pi + o.xxx, seed), sf.x),\n      sf.y\n    ), \n    sf.z\n  );\n\n}\n\nfloat perlinNoise(float p, float scale, float seed) {\n  p *= scale;\n\n  float pi = floor(p);\n  float pf = fract(p);\n\n  float sf = smoothstep(0.0, 1.0, pf);\n\n  float signed = mix(random(pi, seed)*pf, random(pi + 1.0, seed)*(pf - 1.0), sf);\n  \n  // Signed is in range [-1/2, 1/2], map to [0, 1]\n  return 0.5 + signed;\n}\n\nfloat perlinNoise(vec2 p, float scale, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  vec2 pf = fract(p);\n\n  vec2 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  float signed = mix(\n    mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xy, seed), pf - o.xy), sf.x),\n    mix(dot(randomUnit(pi + o.yx, seed), pf - o.yx), dot(randomUnit(pi + o.xx, seed), pf - o.xx), sf.x),\n    sf.y\n  );\n  \n  // Signed is in range [-sqrt(2)/2, sqrt(2)/2], map to [0, 1]\n  return 0.5 + 0.70710678118654752*signed;\n}\n\nfloat perlinNoise(vec3 p, float scale, float seed) {\n  p *= scale;\n\n  vec3 pi = floor(p);\n  vec3 pf = fract(p);\n\n  vec3 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  float signed = mix(\n    mix(\n      mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xyy, seed), pf - o.xyy), sf.x),\n      mix(dot(randomUnit(pi + o.yxy, seed), pf - o.yxy), dot(randomUnit(pi + o.xxy, seed), pf - o.xxy), sf.x),\n      sf.y\n    ),\n    mix(\n      mix(dot(randomUnit(pi + o.yyx, seed), pf - o.yyx), dot(randomUnit(pi + o.xyx, seed), pf - o.xyx), sf.x),\n      mix(dot(randomUnit(pi + o.yxx, seed), pf - o.yxx), dot(randomUnit(pi + o.xxx, seed), pf - o.xxx), sf.x),\n      sf.y\n    ), \n    sf.z\n  );\n\n  // Signed is in range [-sqrt(3/4), sqrt(3/4)], map to [0, 1]\n  return 0.5 + 0.57735026918962576*signed;\n}\n\nfloat worleyNoise(float p, float scale, float seed) {\n  p *= scale;\n\n  float pi = floor(p);\n  float pf = fract(p);\n\n  float minDist = 1e9;\n\n  for (int index = -1; index <= 1; index++) {\n    float fi = float(index);\n    float centerToPosition = fi + random(pi + fi, seed) - pf;\n\n    minDist = min(minDist, abs(centerToPosition));\n  }\n\n  return minDist;\n}\n\nfloat worleyNoise(vec2 p, float scale, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  vec2 pf = fract(p);\n\n  float minDist2 = 1e9;\n\n  for (int row = -1; row <= 1; row++) {\n    for (int col = -1; col <= 1; col++) {\n      vec2 index = vec2(col, row);\n      \n      vec2 centerToPosition = index + random2(pi + index, seed) - pf;\n      float dist2 = dot2(centerToPosition);\n\n      minDist2 = min(minDist2, dist2);\n    }\n  }\n\n  return sqrt(minDist2);\n}\n\nfloat worleyNoise(vec3 p, float scale, float seed) {\n  p *= scale;\n\n  vec3 pi = floor(p);\n  vec3 pf = fract(p);\n\n  float minDist2 = 1e9;\n\n  for (int row = -1; row <= 1; row++) {\n    for (int col = -1; col <= 1; col++) {\n      for (int slice = -1; slice <= 1; slice++) {\n        vec3 index = vec3(col, row, slice);\n      \n        vec3 centerToPosition = index + random3(pi + index, seed) - pf;\n        float dist2 = dot2(centerToPosition);\n\n        minDist2 = min(minDist2, dist2);\n      }\n    }\n  }\n\n  return sqrt(minDist2);\n}\n\n// Adapted version of https://iquilezles.org/articles/voronoise/\nfloat voroNoise(vec2 p, float scale, float disorder, float smoothness, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  vec2 pf = fract(p);\n\n  float s = 1.0;\n  int kernel = 2;\n\n  float power = 64.0 - 63.0*pow(smoothness, 0.1);\n\n  float sum = 0.0;\n  float weightSum = 0.0;\n\n  for (int row = -kernel; row <= kernel; row++) {\n    for (int col = -kernel; col <= kernel; col++) {\n      vec2 index = vec2(col, row);\n\n      // xy is cell center, z is value\n      vec3 data = random3(pi + index, seed);\n\n      vec2 centerToPosition = index + data.xy*disorder - pf;\n\n      float dist2 = dot2(centerToPosition);\n\n      float weight = pow(smoothstep(1.0, 0.0, sqrt(0.5*dist2)), power );\n\n      sum += weight*data.z;\n      weightSum += weight;\n    }\n  }\n\n  return sum / weightSum;\n}\n\nfloat gaboroNoise(vec2 p, float level, float scale, float radius, float freq, float hatchAmount, float hatchAngle, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  float exponent = 1. / (radius*radius);\n\n  float valueSum = 0., weightSum = 0.;\n  for (int i = -1; i <= 1; i++) {\n    for (int j = -1; j <= 1; j++) {\n      vec2 cellIndex = pi + vec2(i, j);\n      vec2 cellCenter = cellIndex + random2(cellIndex, seed);\n      \n      float se = random(cellCenter, seed);\n\n      vec2 diff = p - cellCenter;\n      float rotation = PI*random(se);\n    \n      float weight = exp(-exponent*dot(diff, diff));\n      \n      vec2 texturePosition = diff*freq;\n      \n      float value = max(triangleWave(texturePosition, rotation), hatchAmount*triangleWave(texturePosition, rotation + hatchAngle));\n      \n      weightSum += weight;\n      valueSum += weight*value;\n    }\n  }\n  \n  level = mix(level, sqrt(level), hatchAmount);\n\n  return smoothstep(0.05, -0.05, valueSum / weightSum - level);\n  //return valueSum / weightSum;\n}\n\nfloat idwNoise(float p, float power, float scale, float seed, int window) {\n  p *= scale;\n\n  float pi = floor(p);\n\n  float sum = 0.0;\n  float weightSum = 0.0;\n  float powerCoeff = -power;\n\n  for (int i = -window; i <= window; i++) {\n    float cellCorner = pi + i;\n    float value = random(cellCorner, seed);\n\n    float cellPosition = cellCorner + random(cellCorner, seed);\n\n    float w = pow(abs(p - cellPosition), powerCoeff);\n    \n    if (isinf(w)) return value;\n\n    sum += w*value;\n    weightSum += w; \n  }\n\n  return sum / weightSum;\n}\n\nfloat idwNoise(vec2 p, float power, float scale, float seed, int window) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n\n  float sum = 0.0;\n  float weightSum = 0.0;\n  float powerCoeff = -0.5*power;\n\n  for (int i = -window; i <= window; i++) {\n    for (int j = -window; j <= window; j++) {\n      vec2 cellCorner = pi + vec2(i, j);\n      float value = random(cellCorner, seed);\n\n      vec2 cellPosition = cellCorner + random2(cellCorner, seed);\n\n      float w = pow(dot2(p - cellPosition), powerCoeff);\n      \n      if (isinf(w)) return value;\n\n      sum += w*value;\n      weightSum += w;\n    }  \n  }\n\n  return sum / weightSum;\n}\n\nfloat idwNoise(vec3 p, float power, float scale, float seed, int window) {\n  p *= scale;\n\n  vec3 pi = floor(p);\n\n  float sum = 0.0;\n  float weightSum = 0.0;\n  float powerCoeff = -0.5*power;\n\n  for (int i = -window; i <= window; i++) {\n    for (int j = -window; j <= window; j++) {\n      for (int k = -window; k <= window; k++) {\n        vec3 cellCorner = pi + vec3(i, j, k);\n        float value = random(cellCorner, seed);\n\n        vec3 cellPosition = cellCorner + random3(cellCorner, seed);\n\n        float w = pow(dot2(p - cellPosition), powerCoeff);\n        \n        if (isinf(w)) return value;\n\n        sum += w*value;\n        weightSum += w;\n      }  \n    }  \n  }\n\n  return sum / weightSum;\n}\n\nfloat standardizeOctaveNoise(float value, int octaves) {\n  float norm = clamp((float(octaves) - 1.0)/9.0, 0.0, 1.0);\n  float l = 0.25*pow(norm, 0.125);\n  return (value - l)/(1.0 - 2.0*l);\n}\n\nfloat octaveNoise1D(float p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(float, float)) {\n  p *= scale;\n\n  float sum = 0.0;\n  float amplitude = 1.0;\n  float amplitudeSum = 0.0;\n\n  for (int i = 0; i < octaves; i++) {\n    float value = noise(p, seed + float(i));\n    sum += amplitude*value;\n    amplitudeSum += amplitude;\n\n    p = lacunarity*p + PI;\n    amplitude *= falloff;\n  }\n\n  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);\n  return sum / amplitudeSum;\n}\n\nfloat octaveNoise2D(vec2 p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(vec2, float)) {\n  p *= scale;\n\n  float sum = 0.0;\n  float amplitude = 1.0;\n  float amplitudeSum = 0.0;\n\n  for (int i = 0; i < octaves; i++) {\n    float value = noise(p, seed + float(i));\n    sum += amplitude*value;\n    amplitudeSum += amplitude;\n\n    p = rotate(lacunarity*p, 1.2);\n    amplitude *= falloff;\n  }\n\n  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);\n  return sum / amplitudeSum;\n}\n\nfloat octaveNoise3D(vec3 p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(vec3, float)) {\n  p *= scale;\n\n  float sum = 0.0;\n  float amplitude = 1.0;\n  float amplitudeSum = 0.0;\n\n  vec3 axis = vec3(0.5092382307155079, -0.23643203568934296, 0.8275121249127003);\n\n  for (int i = 0; i < octaves; i++) {\n    float value = noise(p, seed + float(i));\n    sum += amplitude*value;\n    amplitudeSum += amplitude;\n\n    p = axisAngle(lacunarity*p, axis, 1.2);\n    amplitude *= falloff;\n  }\n\n  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);\n  return sum / amplitudeSum;\n}\n\n";
+export declare const noiseDefinition = "\nimport { random, random2, random3, randomUnit } from \"@/random\";\nimport { triangleWave, dot2 } from \"@/utils\";\nimport { rotate, axisAngle } from \"@/geometry\";\nimport { PI } from \"@/constants\";\n\nexport {\n  valueNoise, perlinNoise, worleyNoise, voroNoise, gaboroNoise, \n  octaveNoise1D, octaveNoise2D, octaveNoise3D\n}\n\nfloat valueNoise(float p, float scale, float seed) {\n  p *= scale;\n\n  float pi = floor(p);\n  float pf = fract(p);\n\n  float sf = smoothstep(0.0, 1.0, pf);\n\n  return mix(random(pi, seed), random(pi + 1.0, seed), sf);\n}\n\nfloat valueNoise(vec2 p, float scale, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  vec2 pf = fract(p);\n\n  vec2 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  return mix(\n    mix(random(pi, seed), random(pi + o.xy, seed), sf.x),\n    mix(random(pi + o.yx, seed), random(pi + o.xx, seed), sf.x),\n    sf.y\n  );\n}\n\nfloat valueNoise(vec3 p, float scale, float seed) {\n  p *= scale;\n\n  vec3 pi = floor(p);\n  vec3 pf = fract(p);\n\n  vec3 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  return mix(\n    mix(\n      mix(random(pi, seed), random(pi + o.xyy, seed), sf.x),\n      mix(random(pi + o.yxy, seed), random(pi + o.xxy, seed), sf.x),\n      sf.y\n    ),\n    mix(\n      mix(random(pi + o.yyx, seed), random(pi + o.xyx, seed), sf.x),\n      mix(random(pi + o.yxx, seed), random(pi + o.xxx, seed), sf.x),\n      sf.y\n    ), \n    sf.z\n  );\n\n}\n\nfloat valueNoise(vec4 p, float scale, float seed) {\n  p *= scale;\n\n  vec4 pi = floor(p);\n  vec4 pf = fract(p);\n\n  vec4 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  return mix(\n    mix(\n      mix(\n        mix(random(pi, seed), random(pi + o.xyyy, seed), sf.x),\n        mix(random(pi + o.yxyy, seed), random(pi + o.xxyy, seed), sf.x),\n        sf.y\n      ),\n      mix(\n        mix(random(pi + o.yyxy, seed), random(pi + o.xyxy, seed), sf.x),\n        mix(random(pi + o.yxxy, seed), random(pi + o.xxxy, seed), sf.x),\n        sf.y\n      ), \n      sf.z\n    ),\n    mix(\n      mix(\n        mix(random(pi + o.yyyx, seed), random(pi + o.xyyx, seed), sf.x),\n        mix(random(pi + o.yxyx, seed), random(pi + o.xxyx, seed), sf.x),\n        sf.y\n      ),\n      mix(\n        mix(random(pi + o.yyxx, seed), random(pi + o.xyxx, seed), sf.x),\n        mix(random(pi + o.yxxx, seed), random(pi + o.xxxx, seed), sf.x),\n        sf.y\n      ), \n      sf.z\n    ),\n    sf.w\n  );\n}\n\nfloat perlinNoise(float p, float scale, float seed) {\n  p *= scale;\n\n  float pi = floor(p);\n  float pf = fract(p);\n\n  float sf = smoothstep(0.0, 1.0, pf);\n\n  float signed = mix(random(pi, seed)*pf, random(pi + 1.0, seed)*(pf - 1.0), sf);\n  \n  // Signed is in range [-1/2, 1/2], map to [0, 1]\n  return 0.5 + signed;\n}\n\nfloat perlinNoise(vec2 p, float scale, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  vec2 pf = fract(p);\n\n  vec2 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  float signed = mix(\n    mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xy, seed), pf - o.xy), sf.x),\n    mix(dot(randomUnit(pi + o.yx, seed), pf - o.yx), dot(randomUnit(pi + o.xx, seed), pf - o.xx), sf.x),\n    sf.y\n  );\n  \n  // Signed is in range [-sqrt(2)/2, sqrt(2)/2], map to [0, 1]\n  return 0.5 + 0.70710678118654752*signed;\n}\n\nfloat perlinNoise(vec3 p, float scale, float seed) {\n  p *= scale;\n\n  vec3 pi = floor(p);\n  vec3 pf = fract(p);\n\n  vec3 sf = smoothstep(0.0, 1.0, pf);\n  vec2 o = vec2(1, 0);\n\n  float signed = mix(\n    mix(\n      mix(dot(randomUnit(pi, seed), pf), dot(randomUnit(pi + o.xyy, seed), pf - o.xyy), sf.x),\n      mix(dot(randomUnit(pi + o.yxy, seed), pf - o.yxy), dot(randomUnit(pi + o.xxy, seed), pf - o.xxy), sf.x),\n      sf.y\n    ),\n    mix(\n      mix(dot(randomUnit(pi + o.yyx, seed), pf - o.yyx), dot(randomUnit(pi + o.xyx, seed), pf - o.xyx), sf.x),\n      mix(dot(randomUnit(pi + o.yxx, seed), pf - o.yxx), dot(randomUnit(pi + o.xxx, seed), pf - o.xxx), sf.x),\n      sf.y\n    ), \n    sf.z\n  );\n\n  // Signed is in range [-sqrt(3/4), sqrt(3/4)], map to [0, 1]\n  return 0.5 + 0.57735026918962576*signed;\n}\n\nfloat worleyNoise(float p, float scale, float seed) {\n  p *= scale;\n\n  float pi = floor(p);\n  float pf = fract(p);\n\n  float minDist = 1e9;\n\n  for (int index = -1; index <= 1; index++) {\n    float fi = float(index);\n    float centerToPosition = fi + random(pi + fi, seed) - pf;\n\n    minDist = min(minDist, abs(centerToPosition));\n  }\n\n  return minDist;\n}\n\nfloat worleyNoise(vec2 p, float scale, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  vec2 pf = fract(p);\n\n  float minDist2 = 1e9;\n\n  for (int row = -1; row <= 1; row++) {\n    for (int col = -1; col <= 1; col++) {\n      vec2 index = vec2(col, row);\n      \n      vec2 centerToPosition = index + random2(pi + index, seed) - pf;\n      float dist2 = dot2(centerToPosition);\n\n      minDist2 = min(minDist2, dist2);\n    }\n  }\n\n  return sqrt(minDist2);\n}\n\nfloat worleyNoise(vec3 p, float scale, float seed) {\n  p *= scale;\n\n  vec3 pi = floor(p);\n  vec3 pf = fract(p);\n\n  float minDist2 = 1e9;\n\n  for (int row = -1; row <= 1; row++) {\n    for (int col = -1; col <= 1; col++) {\n      for (int slice = -1; slice <= 1; slice++) {\n        vec3 index = vec3(col, row, slice);\n      \n        vec3 centerToPosition = index + random3(pi + index, seed) - pf;\n        float dist2 = dot2(centerToPosition);\n\n        minDist2 = min(minDist2, dist2);\n      }\n    }\n  }\n\n  return sqrt(minDist2);\n}\n\n// Adapted version of https://iquilezles.org/articles/voronoise/\nfloat voroNoise(vec2 p, float scale, float disorder, float smoothness, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  vec2 pf = fract(p);\n\n  float s = 1.0;\n  int kernel = 2;\n\n  float power = 64.0 - 63.0*pow(smoothness, 0.1);\n\n  float sum = 0.0;\n  float weightSum = 0.0;\n\n  for (int row = -kernel; row <= kernel; row++) {\n    for (int col = -kernel; col <= kernel; col++) {\n      vec2 index = vec2(col, row);\n\n      // xy is cell center, z is value\n      vec3 data = random3(pi + index, seed);\n\n      vec2 centerToPosition = index + data.xy*disorder - pf;\n\n      float dist2 = dot2(centerToPosition);\n\n      float weight = pow(smoothstep(1.0, 0.0, sqrt(0.5*dist2)), power );\n\n      sum += weight*data.z;\n      weightSum += weight;\n    }\n  }\n\n  return sum / weightSum;\n}\n\nfloat gaboroNoise(vec2 p, float level, float scale, float radius, float freq, float hatchAmount, float hatchAngle, float seed) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n  float exponent = 1. / (radius*radius);\n\n  float valueSum = 0., weightSum = 0.;\n  for (int i = -1; i <= 1; i++) {\n    for (int j = -1; j <= 1; j++) {\n      vec2 cellIndex = pi + vec2(i, j);\n      vec2 cellCenter = cellIndex + random2(cellIndex, seed);\n      \n      float se = random(cellCenter, seed);\n\n      vec2 diff = p - cellCenter;\n      float rotation = PI*random(se);\n    \n      float weight = exp(-exponent*dot(diff, diff));\n      \n      vec2 texturePosition = diff*freq;\n      \n      float value = max(triangleWave(texturePosition, rotation), hatchAmount*triangleWave(texturePosition, rotation + hatchAngle));\n      \n      weightSum += weight;\n      valueSum += weight*value;\n    }\n  }\n  \n  level = mix(level, sqrt(level), hatchAmount);\n\n  return smoothstep(0.05, -0.05, valueSum / weightSum - level);\n  //return valueSum / weightSum;\n}\n\nfloat idwNoise(float p, float power, float scale, float seed, int window) {\n  p *= scale;\n\n  float pi = floor(p);\n\n  float sum = 0.0;\n  float weightSum = 0.0;\n  float powerCoeff = -power;\n\n  for (int i = -window; i <= window; i++) {\n    float cellCorner = pi + i;\n    float value = random(cellCorner, seed);\n\n    float cellPosition = cellCorner + random(cellCorner, seed);\n\n    float w = pow(abs(p - cellPosition), powerCoeff);\n    \n    if (isinf(w)) return value;\n\n    sum += w*value;\n    weightSum += w; \n  }\n\n  return sum / weightSum;\n}\n\nfloat idwNoise(vec2 p, float power, float scale, float seed, int window) {\n  p *= scale;\n\n  vec2 pi = floor(p);\n\n  float sum = 0.0;\n  float weightSum = 0.0;\n  float powerCoeff = -0.5*power;\n\n  for (int i = -window; i <= window; i++) {\n    for (int j = -window; j <= window; j++) {\n      vec2 cellCorner = pi + vec2(i, j);\n      float value = random(cellCorner, seed);\n\n      vec2 cellPosition = cellCorner + random2(cellCorner, seed);\n\n      float w = pow(dot2(p - cellPosition), powerCoeff);\n      \n      if (isinf(w)) return value;\n\n      sum += w*value;\n      weightSum += w;\n    }  \n  }\n\n  return sum / weightSum;\n}\n\nfloat idwNoise(vec3 p, float power, float scale, float seed, int window) {\n  p *= scale;\n\n  vec3 pi = floor(p);\n\n  float sum = 0.0;\n  float weightSum = 0.0;\n  float powerCoeff = -0.5*power;\n\n  for (int i = -window; i <= window; i++) {\n    for (int j = -window; j <= window; j++) {\n      for (int k = -window; k <= window; k++) {\n        vec3 cellCorner = pi + vec3(i, j, k);\n        float value = random(cellCorner, seed);\n\n        vec3 cellPosition = cellCorner + random3(cellCorner, seed);\n\n        float w = pow(dot2(p - cellPosition), powerCoeff);\n        \n        if (isinf(w)) return value;\n\n        sum += w*value;\n        weightSum += w;\n      }  \n    }  \n  }\n\n  return sum / weightSum;\n}\n\nfloat standardizeOctaveNoise(float value, int octaves) {\n  float norm = clamp((float(octaves) - 1.0)/9.0, 0.0, 1.0);\n  float l = 0.25*pow(norm, 0.125);\n  return (value - l)/(1.0 - 2.0*l);\n}\n\nfloat octaveNoise1D(float p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(float, float)) {\n  p *= scale;\n\n  float sum = 0.0;\n  float amplitude = 1.0;\n  float amplitudeSum = 0.0;\n\n  for (int i = 0; i < octaves; i++) {\n    float value = noise(p, seed + float(i));\n    sum += amplitude*value;\n    amplitudeSum += amplitude;\n\n    p = lacunarity*p + PI;\n    amplitude *= falloff;\n  }\n\n  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);\n  return sum / amplitudeSum;\n}\n\nfloat octaveNoise2D(vec2 p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(vec2, float)) {\n  p *= scale;\n\n  float sum = 0.0;\n  float amplitude = 1.0;\n  float amplitudeSum = 0.0;\n\n  for (int i = 0; i < octaves; i++) {\n    float value = noise(p, seed + float(i));\n    sum += amplitude*value;\n    amplitudeSum += amplitude;\n\n    p = rotate(lacunarity*p, 1.2);\n    amplitude *= falloff;\n  }\n\n  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);\n  return sum / amplitudeSum;\n}\n\nfloat octaveNoise3D(vec3 p, float scale, int octaves, float falloff, float lacunarity, float seed, float noise(vec3, float)) {\n  p *= scale;\n\n  float sum = 0.0;\n  float amplitude = 1.0;\n  float amplitudeSum = 0.0;\n\n  vec3 axis = vec3(0.5092382307155079, -0.23643203568934296, 0.8275121249127003);\n\n  for (int i = 0; i < octaves; i++) {\n    float value = noise(p, seed + float(i));\n    sum += amplitude*value;\n    amplitudeSum += amplitude;\n\n    p = axisAngle(lacunarity*p, axis, 1.2);\n    amplitude *= falloff;\n  }\n\n  // return standardizeOctaveNoise(sum / amplitudeSum, octaves);\n  return sum / amplitudeSum;\n}\n\n";

dist/shader-modules/modules/noise.js

@@ -64,2 +64,42 @@ export const noiseDefinition = /*glsl*/ `
 
+float valueNoise(vec4 p, float scale, float seed) {
+  p *= scale;
+
+  vec4 pi = floor(p);
+  vec4 pf = fract(p);
+
+  vec4 sf = smoothstep(0.0, 1.0, pf);
+  vec2 o = vec2(1, 0);
+
+  return mix(
+    mix(
+      mix(
+        mix(random(pi, seed), random(pi + o.xyyy, seed), sf.x),
+        mix(random(pi + o.yxyy, seed), random(pi + o.xxyy, seed), sf.x),
+        sf.y
+      ),
+      mix(
+        mix(random(pi + o.yyxy, seed), random(pi + o.xyxy, seed), sf.x),
+        mix(random(pi + o.yxxy, seed), random(pi + o.xxxy, seed), sf.x),
+        sf.y
+      ), 
+      sf.z
+    ),
+    mix(
+      mix(
+        mix(random(pi + o.yyyx, seed), random(pi + o.xyyx, seed), sf.x),
+        mix(random(pi + o.yxyx, seed), random(pi + o.xxyx, seed), sf.x),
+        sf.y
+      ),
+      mix(
+        mix(random(pi + o.yyxx, seed), random(pi + o.xyxx, seed), sf.x),
+        mix(random(pi + o.yxxx, seed), random(pi + o.xxxx, seed), sf.x),
+        sf.y
+      ), 
+      sf.z
+    ),
+    sf.w
+  );
+}
+
 float perlinNoise(float p, float scale, float seed) {
@@ -66,0 +106,0 @@ p *= scale;

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

@@ -1,1 +0,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  randomGauss,\n  randomUnit\n };\n\nuint hash(uint value) {\n  value += 2127912214u;\n  value ^= value >> 12;\n  value *= 3345072700u;\n  value ^= value >> 19;\n\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\nvec4 random4(vec4 p, float seed) {\n  return vec4(\n    random(p, seed),\n    random(p, random(seed, 1.0)),\n    random(p, random(seed, 2.0)),\n    random(p, random(seed, 3.0))\n  );\n}\n\nvec4 random4(vec4 p, float seed) {\n  return random4(p, 0.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\nfloat randomGaussian(vec4 p, float seed) {\n  float u1 = random(p, seed);\n  float u2 = random(p, random(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\nvec4 randomUnit(vec4 p, float seed) {\n  return normalize(vec4(\n    randomGaussian(p, seed),\n    randomGaussian(p, random(seed, 1.)),\n    randomGaussian(p, random(seed, 2.)),\n    randomGaussian(p, random(seed, 3.))\n  ));\n}\n\n";

dist/shader-modules/modules/random.js

@@ -5,3 +5,3 @@ export const randomDefinition = /*glsl*/ `
 export { 
-  random, random2, random3,
+  random, random2, random3, random4,
   randomGauss,
@@ -12,7 +12,7 @@ randomUnit
 uint hash(uint value) {
-  value ^= value >> 16;
-  value *= 569420461u;
-  value ^= value >> 15;
-  value *= 3545902487u;
-  value ^= value >> 15;
+  value += 2127912214u;
+  value ^= value >> 12;
+  value *= 3345072700u;
+  value ^= value >> 19;
+
   return value;
@@ -128,2 +128,15 @@ }
 
+vec4 random4(vec4 p, float seed) {
+  return vec4(
+    random(p, seed),
+    random(p, random(seed, 1.0)),
+    random(p, random(seed, 2.0)),
+    random(p, random(seed, 3.0))
+  );
+}
+
+vec4 random4(vec4 p, float seed) {
+  return random4(p, 0.0);
+}
+
 float randomGaussian(vec3 p, float seed) {
@@ -135,2 +148,8 @@ float u1 = random(vec4(p, 1), seed);
 
+float randomGaussian(vec4 p, float seed) {
+  float u1 = random(p, seed);
+  float u2 = random(p, random(seed));
+  return sqrt(-2.0 * log(u1)) * cos(TWO_PI * u2);
+}
+
 vec2 randomUnit(vec2 p, float seed) {
@@ -149,4 +168,11 @@ float direction = TWO_PI*random(p, seed);
 
+vec4 randomUnit(vec4 p, float seed) {
+  return normalize(vec4(
+    randomGaussian(p, seed),
+    randomGaussian(p, random(seed, 1.)),
+    randomGaussian(p, random(seed, 2.)),
+    randomGaussian(p, random(seed, 3.))
+  ));
+}
 
-
 `;

package.json

 {
   "name": "@matboks/utilities",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "./dist/index.js",
@@ -15,3 +15,3 @@ "files": [
     "earcut": "^3.0.2",
-    "glsl-modules": "^0.5.0",
+    "glsl-modules": "^0.7.0",
     "marching-squares": "^1.0.0",
@@ -18,0 +18,0 @@ "polyclip-ts": "^0.16.8"

New alerts

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Fixed alerts

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

274018

4.72%

Number of package files

193

9.04%

Lines of code

6203

3.9%

Worsened metrics

Number of low supply chain risk alerts

23

4.55%

Dependency changes

• + Added

  glsl-modules@0.7.0
  (transitive)

• - Removed

  glsl-modules@0.5.0
  (transitive)

• Updated

  glsl-modules@^0.7.0