@paper-design/shaders 0.0.32 → 0.0.34

package/dist/shaders/neuro-noise.d.ts

@@ -1,23 +1,27 @@
-import type { ShaderMotionParams } from '../shader-mount';
-import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing';
+import type { ShaderMotionParams } from '../shader-mount.js';
+import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';
 /**
- * Neuro Noise Pattern
- * The original artwork: https://codepen.io/ksenia-k/full/vYwgrWv by Ksenia Kondrashova
- * Renders a fractal-like structure made of several layers of since-arches
  *
- * Uniforms include:
- * u_colorFront - the front color of pattern
- * u_colorBack - the back color of pattern
- * u_brightness - the power (brightness) of pattern lines
+ * Fractal-like structure made of several layers of since arches
+ * Original algorithm: https://x.com/zozuar/status/1625182758745128981/
+ *
+ * Uniforms:
+ * - u_colorBack, u_colorMid, u_colorFront (RGBA)
+ * - u_brightness, u_contrast
+ *
  */
 export declare const neuroNoiseFragmentShader: string;
 export interface NeuroNoiseUniforms extends ShaderSizingUniforms {
     u_colorFront: [number, number, number, number];
+    u_colorMid: [number, number, number, number];
     u_colorBack: [number, number, number, number];
     u_brightness: number;
+    u_contrast: number;
 }
 export interface NeuroNoiseParams extends ShaderSizingParams, ShaderMotionParams {
     colorFront?: string;
+    colorMid?: string;
     colorBack?: string;
     brightness?: number;
+    contrast?: number;
 }

package/dist/shaders/neuro-noise.js

@@ -0,0 +1,81 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+import { sizingVariablesDeclaration } from "../shader-sizing.js";
+import { declareRotate, colorBandingFix } from "../shader-utils.js";
+const neuroNoiseFragmentShader = `#version 300 es
+precision mediump float;
+
+uniform float u_time;
+uniform vec2 u_resolution;
+uniform float u_pixelRatio;
+
+uniform vec4 u_colorFront;
+uniform vec4 u_colorMid;
+uniform vec4 u_colorBack;
+uniform float u_brightness;
+uniform float u_contrast;
+
+
+${sizingVariablesDeclaration}
+
+out vec4 fragColor;
+
+${declareRotate}
+
+float neuroShape(vec2 uv, float t) {
+  vec2 sine_acc = vec2(0.);
+  vec2 res = vec2(0.);
+  float scale = 8.;
+
+  for (int j = 0; j < 15; j++) {
+    uv = rotate(uv, 1.);
+    sine_acc = rotate(sine_acc, 1.);
+    vec2 layer = uv * scale + float(j) + sine_acc - t;
+    sine_acc += sin(layer);
+    res += (.5 + .5 * cos(layer)) / scale;
+    scale *= (1.2);
+  }
+  return res.x + res.y;
+}
+
+void main() {
+  vec2 shape_uv = v_patternUV;
+
+  shape_uv *= .0013;
+
+  float t = .5 * u_time;
+
+  float noise = neuroShape(shape_uv, t);
+
+  noise = (1. + u_brightness) * pow(noise, 2.);
+  noise = pow(noise, .7 + 6. * u_contrast);
+  noise = min(1.4, noise);
+
+  float blend = smoothstep(0.7, 1.4, noise);
+
+  vec4 frontC = u_colorFront;
+  frontC.rgb *= frontC.a;
+  vec4 midC = u_colorMid;
+  midC.rgb *= midC.a;
+  vec4 blendFront = mix(midC, frontC, blend);
+
+  float safeNoise = max(noise, 0.0);
+  vec3 color = blendFront.rgb * safeNoise;
+  float opacity = clamp(blendFront.a * safeNoise, 0., 1.);
+
+  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;
+  color = color + bgColor * (1. - opacity);
+  opacity = opacity + u_colorBack.a * (1. - opacity);
+
+  ${colorBandingFix}
+
+  fragColor = vec4(color, opacity);
+}
+`;
+export {
+  neuroNoiseFragmentShader
+};
+//# sourceMappingURL=neuro-noise.js.map

package/dist/shaders/neuro-noise.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shaders/neuro-noise.ts"],
+  "sourcesContent": ["import type { ShaderMotionParams } from '../shader-mount.js';\nimport { sizingVariablesDeclaration, type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';\nimport { declareRotate, colorBandingFix } from '../shader-utils.js';\n\n/**\n *\n * Fractal-like structure made of several layers of since arches\n * Original algorithm: https://x.com/zozuar/status/1625182758745128981/\n *\n * Uniforms:\n * - u_colorBack, u_colorMid, u_colorFront (RGBA)\n * - u_brightness, u_contrast\n *\n */\n\nexport const neuroNoiseFragmentShader: string = `#version 300 es\nprecision mediump float;\n\nuniform float u_time;\nuniform vec2 u_resolution;\nuniform float u_pixelRatio;\n\nuniform vec4 u_colorFront;\nuniform vec4 u_colorMid;\nuniform vec4 u_colorBack;\nuniform float u_brightness;\nuniform float u_contrast;\n\n\n${sizingVariablesDeclaration}\n\nout vec4 fragColor;\n\n${declareRotate}\n\nfloat neuroShape(vec2 uv, float t) {\n  vec2 sine_acc = vec2(0.);\n  vec2 res = vec2(0.);\n  float scale = 8.;\n\n  for (int j = 0; j < 15; j++) {\n    uv = rotate(uv, 1.);\n    sine_acc = rotate(sine_acc, 1.);\n    vec2 layer = uv * scale + float(j) + sine_acc - t;\n    sine_acc += sin(layer);\n    res += (.5 + .5 * cos(layer)) / scale;\n    scale *= (1.2);\n  }\n  return res.x + res.y;\n}\n\nvoid main() {\n  vec2 shape_uv = v_patternUV;\n\n  shape_uv *= .0013;\n\n  float t = .5 * u_time;\n\n  float noise = neuroShape(shape_uv, t);\n\n  noise = (1. + u_brightness) * pow(noise, 2.);\n  noise = pow(noise, .7 + 6. * u_contrast);\n  noise = min(1.4, noise);\n\n  float blend = smoothstep(0.7, 1.4, noise);\n\n  vec4 frontC = u_colorFront;\n  frontC.rgb *= frontC.a;\n  vec4 midC = u_colorMid;\n  midC.rgb *= midC.a;\n  vec4 blendFront = mix(midC, frontC, blend);\n\n  float safeNoise = max(noise, 0.0);\n  vec3 color = blendFront.rgb * safeNoise;\n  float opacity = clamp(blendFront.a * safeNoise, 0., 1.);\n\n  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;\n  color = color + bgColor * (1. - opacity);\n  opacity = opacity + u_colorBack.a * (1. - opacity);\n\n  ${colorBandingFix}\n\n  fragColor = vec4(color, opacity);\n}\n`;\n\nexport interface NeuroNoiseUniforms extends ShaderSizingUniforms {\n  u_colorFront: [number, number, number, number];\n  u_colorMid: [number, number, number, number];\n  u_colorBack: [number, number, number, number];\n  u_brightness: number;\n  u_contrast: number;\n}\n\nexport interface NeuroNoiseParams extends ShaderSizingParams, ShaderMotionParams {\n  colorFront?: string;\n  colorMid?: string;\n  colorBack?: string;\n  brightness?: number;\n  contrast?: number;\n}\n"],
+  "mappings": ";;;;;AACA,SAAS,kCAAsF;AAC/F,SAAS,eAAe,uBAAuB;AAaxC,MAAM,2BAAmC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc9C,0BAA0B;AAAA;AAAA;AAAA;AAAA,EAI1B,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IA+CX,eAAe;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/shaders/perlin-noise.d.ts

@@ -1,25 +1,21 @@
-import type { ShaderMotionParams } from '../shader-mount';
-import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing';
+import type { ShaderMotionParams } from '../shader-mount.js';
+import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';
 /**
- * 3d Perlin noise with exposed parameters
- * Based on https://www.shadertoy.com/view/NlSGDz
+ * 3d Perlin noise; original algorithm: https://www.shadertoy.com/view/NlSGDz
+ *
+ * Uniforms:
+ * - u_colorBack, u_colorFront (RGBA)
+ * - u_proportion: (0..1) blend point between 2 colors (0.5 = equal distribution)
+ * - u_softness: color transition sharpness (0 = hard edge, 1 = smooth fade)
+ * - u_octaveCount: more octaves => more detailed pattern
+ * - u_persistence: roughness, falloff between octaves
+ * - u_lacunarity: frequency step, typically around 2, defines how compressed is the pattern
  *
- * Uniforms include:
- * u_color1 - the first mixed color
- * u_color2 - the second mixed color
- * u_proportion (0 .. 1) - the proportion between u_color1 and u_color2;
- * u_softness - the sharpness of the transition between u_color1 and u_color2 in the noise output
- * u_octaveCount - the number of octaves for Perlin noise;
- *    higher values increase the complexity of the noise
- * u_persistence (0 .. 1) - the amplitude of each successive octave of the noise;
- *    lower values make higher octaves less pronounced
- * u_lacunarity - the frequency of each successive octave of the noise;
- *    higher values increase the detail
  */
 export declare const perlinNoiseFragmentShader: string;
 export interface PerlinNoiseUniforms extends ShaderSizingUniforms {
-    u_color1: [number, number, number, number];
-    u_color2: [number, number, number, number];
+    u_colorFront: [number, number, number, number];
+    u_colorBack: [number, number, number, number];
     u_proportion: number;
     u_softness: number;
     u_octaveCount: number;
@@ -27,8 +23,8 @@ export interface PerlinNoiseUniforms extends ShaderSizingUniforms {
     u_lacunarity: number;
 }
 export interface PerlinNoiseParams extends ShaderSizingParams, ShaderMotionParams {
-    color1?: string;
-    color2?: string;
+    colorFront?: string;
+    colorBack?: string;
     proportion?: number;
     softness?: number;
     octaveCount?: number;

package/dist/shaders/perlin-noise.js

@@ -0,0 +1,201 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+import { sizingVariablesDeclaration } from "../shader-sizing.js";
+import { declarePI, colorBandingFix } from "../shader-utils.js";
+const perlinNoiseFragmentShader = `#version 300 es
+precision mediump float;
+
+uniform float u_time;
+
+uniform vec4 u_colorFront;
+uniform vec4 u_colorBack;
+uniform float u_proportion;
+uniform float u_softness;
+uniform float u_octaveCount;
+uniform float u_persistence;
+uniform float u_lacunarity;
+
+${sizingVariablesDeclaration}
+
+out vec4 fragColor;
+
+${declarePI}
+
+uint hash(uint x, uint seed) {
+  const uint m = 0x5bd1e995U;
+  uint hash = seed;
+    // process input
+    uint k = x;
+    k *= m;
+    k ^= k >> 24;
+    k *= m;
+    hash *= m;
+    hash ^= k;
+    // some final mixing
+    hash ^= hash >> 13;
+    hash *= m;
+    hash ^= hash >> 15;
+    return hash;
+}
+
+uint hash(uvec3 x, uint seed){
+    const uint m = 0x5bd1e995U;
+    uint hash = seed;
+    // process first vector element
+    uint k = x.x;
+    k *= m;
+    k ^= k >> 24;
+    k *= m;
+    hash *= m;
+    hash ^= k;
+    // process second vector element
+    k = x.y;
+    k *= m;
+    k ^= k >> 24;
+    k *= m;
+    hash *= m;
+    hash ^= k;
+    // process third vector element
+    k = x.z;
+    k *= m;
+    k ^= k >> 24;
+    k *= m;
+    hash *= m;
+    hash ^= k;
+    // some final mixing
+    hash ^= hash >> 13;
+    hash *= m;
+    hash ^= hash >> 15;
+    return hash;
+}
+
+
+vec3 gradientdy(uint hash) {
+    switch (int(hash) & 15) { // look at the last four bits to pick a gradient dy
+    case 0:
+        return vec3(1, 1, 0);
+    case 1:
+        return vec3(-1, 1, 0);
+    case 2:
+        return vec3(1, -1, 0);
+    case 3:
+        return vec3(-1, -1, 0);
+    case 4:
+        return vec3(1, 0, 1);
+    case 5:
+        return vec3(-1, 0, 1);
+    case 6:
+        return vec3(1, 0, -1);
+    case 7:
+        return vec3(-1, 0, -1);
+    case 8:
+        return vec3(0, 1, 1);
+    case 9:
+        return vec3(0, -1, 1);
+    case 10:
+        return vec3(0, 1, -1);
+    case 11:
+        return vec3(0, -1, -1);
+    case 12:
+        return vec3(1, 1, 0);
+    case 13:
+        return vec3(-1, 1, 0);
+    case 14:
+        return vec3(0, -1, 1);
+    case 15:
+        return vec3(0, -1, -1);
+    }
+}
+
+float interpolate(float value1, float value2, float value3, float value4, float value5, float value6, float value7, float value8, vec3 t) {
+    return mix(
+        mix(mix(value1, value2, t.x), mix(value3, value4, t.x), t.y),
+        mix(mix(value5, value6, t.x), mix(value7, value8, t.x), t.y),
+        t.z
+    );
+}
+
+vec3 fade(vec3 t) {
+    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+}
+
+float perlinNoise(vec3 position, uint seed) {
+    position += 1e+4;
+    vec3 floorPosition = floor(position);
+    vec3 fractPosition = fract(position);
+    uvec3 cellCoordinates = uvec3(floorPosition);
+    float value1 = dot(gradientdy(hash(cellCoordinates, seed)), fractPosition);
+    float value2 = dot(gradientdy(hash((cellCoordinates + uvec3(1, 0, 0)), seed)), fractPosition - vec3(1, 0, 0));
+    float value3 = dot(gradientdy(hash((cellCoordinates + uvec3(0, 1, 0)), seed)), fractPosition - vec3(0, 1, 0));
+    float value4 = dot(gradientdy(hash((cellCoordinates + uvec3(1, 1, 0)), seed)), fractPosition - vec3(1, 1, 0));
+    float value5 = dot(gradientdy(hash((cellCoordinates + uvec3(0, 0, 1)), seed)), fractPosition - vec3(0, 0, 1));
+    float value6 = dot(gradientdy(hash((cellCoordinates + uvec3(1, 0, 1)), seed)), fractPosition - vec3(1, 0, 1));
+    float value7 = dot(gradientdy(hash((cellCoordinates + uvec3(0, 1, 1)), seed)), fractPosition - vec3(0, 1, 1));
+    float value8 = dot(gradientdy(hash((cellCoordinates + uvec3(1, 1, 1)), seed)), fractPosition - vec3(1, 1, 1));
+    return interpolate(value1, value2, value3, value4, value5, value6, value7, value8, fade(fractPosition));
+}
+
+float p_noise(vec3 position, int octaveCount, float persistence, float lacunarity) {
+    float value = 0.0;
+    float amplitude = 1.0;
+    float currentFrequency = 10.;
+    uint currentSeed = uint(0);
+    for (int i = 0; i < octaveCount; i++) {
+        currentSeed = hash(currentSeed, 0x0U);
+        value += perlinNoise(position * currentFrequency, currentSeed) * amplitude;
+        amplitude *= persistence;
+        currentFrequency *= lacunarity;
+    }
+    return value;
+}
+
+float get_max_amp(float persistence, float octaveCount) {
+    persistence *= .999;
+    return (1. - pow(persistence, octaveCount)) / (1. - persistence);
+}
+
+void main() {
+  vec2 uv = v_patternUV;
+
+  uv *= .005;
+  float t = .2 * u_time;
+
+  vec3 p = vec3(uv, t);
+
+  float oct_count = max(0., floor(u_octaveCount));
+  float persistence = clamp(u_persistence, 0., 1.);
+  float noise = p_noise(p, int(oct_count), persistence, u_lacunarity);
+
+  float max_amp = get_max_amp(persistence, oct_count);
+  float noise_normalized = (noise + max_amp) / (2. * max_amp) + (u_proportion - .5);
+  float sharpness = clamp(u_softness, 0., 1.);
+  float smooth_w = 0.5 * fwidth(noise_normalized);
+  float res = smoothstep(
+    .5 - .5 * sharpness - smooth_w,
+    .5 + .5 * sharpness + smooth_w,
+    noise_normalized
+  );
+
+  vec3 fgColor = u_colorFront.rgb * u_colorFront.a;
+  float fgOpacity = u_colorFront.a;
+  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;
+  float bgOpacity = u_colorBack.a;
+
+  vec3 color = fgColor * res;
+  float opacity = fgOpacity * res;
+
+  color += bgColor * (1. - opacity);
+  opacity += bgOpacity * (1. - opacity);
+
+  ${colorBandingFix}
+
+  fragColor = vec4(color, opacity);
+}
+`;
+export {
+  perlinNoiseFragmentShader
+};
+//# sourceMappingURL=perlin-noise.js.map

package/dist/shaders/perlin-noise.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shaders/perlin-noise.ts"],
+  "sourcesContent": ["import type { ShaderMotionParams } from '../shader-mount.js';\nimport { sizingVariablesDeclaration, type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';\nimport { declarePI, colorBandingFix } from '../shader-utils.js';\n\n/**\n * 3d Perlin noise; original algorithm: https://www.shadertoy.com/view/NlSGDz\n *\n * Uniforms:\n * - u_colorBack, u_colorFront (RGBA)\n * - u_proportion: (0..1) blend point between 2 colors (0.5 = equal distribution)\n * - u_softness: color transition sharpness (0 = hard edge, 1 = smooth fade)\n * - u_octaveCount: more octaves => more detailed pattern\n * - u_persistence: roughness, falloff between octaves\n * - u_lacunarity: frequency step, typically around 2, defines how compressed is the pattern\n *\n */\n\nexport const perlinNoiseFragmentShader: string = `#version 300 es\nprecision mediump float;\n\nuniform float u_time;\n\nuniform vec4 u_colorFront;\nuniform vec4 u_colorBack;\nuniform float u_proportion;\nuniform float u_softness;\nuniform float u_octaveCount;\nuniform float u_persistence;\nuniform float u_lacunarity;\n\n${sizingVariablesDeclaration}\n\nout vec4 fragColor;\n\n${declarePI}\n\nuint hash(uint x, uint seed) {\n  const uint m = 0x5bd1e995U;\n  uint hash = seed;\n    // process input\n    uint k = x;\n    k *= m;\n    k ^= k >> 24;\n    k *= m;\n    hash *= m;\n    hash ^= k;\n    // some final mixing\n    hash ^= hash >> 13;\n    hash *= m;\n    hash ^= hash >> 15;\n    return hash;\n}\n\nuint hash(uvec3 x, uint seed){\n    const uint m = 0x5bd1e995U;\n    uint hash = seed;\n    // process first vector element\n    uint k = x.x;\n    k *= m;\n    k ^= k >> 24;\n    k *= m;\n    hash *= m;\n    hash ^= k;\n    // process second vector element\n    k = x.y;\n    k *= m;\n    k ^= k >> 24;\n    k *= m;\n    hash *= m;\n    hash ^= k;\n    // process third vector element\n    k = x.z;\n    k *= m;\n    k ^= k >> 24;\n    k *= m;\n    hash *= m;\n    hash ^= k;\n    // some final mixing\n    hash ^= hash >> 13;\n    hash *= m;\n    hash ^= hash >> 15;\n    return hash;\n}\n\n\nvec3 gradientdy(uint hash) {\n    switch (int(hash) & 15) { // look at the last four bits to pick a gradient dy\n    case 0:\n        return vec3(1, 1, 0);\n    case 1:\n        return vec3(-1, 1, 0);\n    case 2:\n        return vec3(1, -1, 0);\n    case 3:\n        return vec3(-1, -1, 0);\n    case 4:\n        return vec3(1, 0, 1);\n    case 5:\n        return vec3(-1, 0, 1);\n    case 6:\n        return vec3(1, 0, -1);\n    case 7:\n        return vec3(-1, 0, -1);\n    case 8:\n        return vec3(0, 1, 1);\n    case 9:\n        return vec3(0, -1, 1);\n    case 10:\n        return vec3(0, 1, -1);\n    case 11:\n        return vec3(0, -1, -1);\n    case 12:\n        return vec3(1, 1, 0);\n    case 13:\n        return vec3(-1, 1, 0);\n    case 14:\n        return vec3(0, -1, 1);\n    case 15:\n        return vec3(0, -1, -1);\n    }\n}\n\nfloat interpolate(float value1, float value2, float value3, float value4, float value5, float value6, float value7, float value8, vec3 t) {\n    return mix(\n        mix(mix(value1, value2, t.x), mix(value3, value4, t.x), t.y),\n        mix(mix(value5, value6, t.x), mix(value7, value8, t.x), t.y),\n        t.z\n    );\n}\n\nvec3 fade(vec3 t) {\n    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);\n}\n\nfloat perlinNoise(vec3 position, uint seed) {\n    position += 1e+4;\n    vec3 floorPosition = floor(position);\n    vec3 fractPosition = fract(position);\n    uvec3 cellCoordinates = uvec3(floorPosition);\n    float value1 = dot(gradientdy(hash(cellCoordinates, seed)), fractPosition);\n    float value2 = dot(gradientdy(hash((cellCoordinates + uvec3(1, 0, 0)), seed)), fractPosition - vec3(1, 0, 0));\n    float value3 = dot(gradientdy(hash((cellCoordinates + uvec3(0, 1, 0)), seed)), fractPosition - vec3(0, 1, 0));\n    float value4 = dot(gradientdy(hash((cellCoordinates + uvec3(1, 1, 0)), seed)), fractPosition - vec3(1, 1, 0));\n    float value5 = dot(gradientdy(hash((cellCoordinates + uvec3(0, 0, 1)), seed)), fractPosition - vec3(0, 0, 1));\n    float value6 = dot(gradientdy(hash((cellCoordinates + uvec3(1, 0, 1)), seed)), fractPosition - vec3(1, 0, 1));\n    float value7 = dot(gradientdy(hash((cellCoordinates + uvec3(0, 1, 1)), seed)), fractPosition - vec3(0, 1, 1));\n    float value8 = dot(gradientdy(hash((cellCoordinates + uvec3(1, 1, 1)), seed)), fractPosition - vec3(1, 1, 1));\n    return interpolate(value1, value2, value3, value4, value5, value6, value7, value8, fade(fractPosition));\n}\n\nfloat p_noise(vec3 position, int octaveCount, float persistence, float lacunarity) {\n    float value = 0.0;\n    float amplitude = 1.0;\n    float currentFrequency = 10.;\n    uint currentSeed = uint(0);\n    for (int i = 0; i < octaveCount; i++) {\n        currentSeed = hash(currentSeed, 0x0U);\n        value += perlinNoise(position * currentFrequency, currentSeed) * amplitude;\n        amplitude *= persistence;\n        currentFrequency *= lacunarity;\n    }\n    return value;\n}\n\nfloat get_max_amp(float persistence, float octaveCount) {\n    persistence *= .999;\n    return (1. - pow(persistence, octaveCount)) / (1. - persistence);\n}\n\nvoid main() {\n  vec2 uv = v_patternUV;\n\n  uv *= .005;\n  float t = .2 * u_time;\n\n  vec3 p = vec3(uv, t);\n\n  float oct_count = max(0., floor(u_octaveCount));\n  float persistence = clamp(u_persistence, 0., 1.);\n  float noise = p_noise(p, int(oct_count), persistence, u_lacunarity);\n\n  float max_amp = get_max_amp(persistence, oct_count);\n  float noise_normalized = (noise + max_amp) / (2. * max_amp) + (u_proportion - .5);\n  float sharpness = clamp(u_softness, 0., 1.);\n  float smooth_w = 0.5 * fwidth(noise_normalized);\n  float res = smoothstep(\n    .5 - .5 * sharpness - smooth_w,\n    .5 + .5 * sharpness + smooth_w,\n    noise_normalized\n  );\n\n  vec3 fgColor = u_colorFront.rgb * u_colorFront.a;\n  float fgOpacity = u_colorFront.a;\n  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;\n  float bgOpacity = u_colorBack.a;\n\n  vec3 color = fgColor * res;\n  float opacity = fgOpacity * res;\n\n  color += bgColor * (1. - opacity);\n  opacity += bgOpacity * (1. - opacity);\n\n  ${colorBandingFix}\n\n  fragColor = vec4(color, opacity);\n}\n`;\n\nexport interface PerlinNoiseUniforms extends ShaderSizingUniforms {\n  u_colorFront: [number, number, number, number];\n  u_colorBack: [number, number, number, number];\n  u_proportion: number;\n  u_softness: number;\n  u_octaveCount: number;\n  u_persistence: number;\n  u_lacunarity: number;\n}\n\nexport interface PerlinNoiseParams extends ShaderSizingParams, ShaderMotionParams {\n  colorFront?: string;\n  colorBack?: string;\n  proportion?: number;\n  softness?: number;\n  octaveCount?: number;\n  persistence?: number;\n  lacunarity?: number;\n}\n"],
+  "mappings": ";;;;;AACA,SAAS,kCAAsF;AAC/F,SAAS,WAAW,uBAAuB;AAepC,MAAM,4BAAoC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAa/C,0BAA0B;AAAA;AAAA;AAAA;AAAA,EAI1B,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAwKP,eAAe;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/shaders/pulsing-border.d.ts

@@ -1,27 +1,26 @@
-import type { vec4 } from '../types';
-import type { ShaderMotionParams } from '../shader-mount';
-import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing';
+import type { vec4 } from '../types.js';
+import type { ShaderMotionParams } from '../shader-mount.js';
+import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';
 export declare const pulsingBorderMeta: {
     readonly maxColorCount: 5;
     readonly maxSpotsPerColor: 5;
 };
 /**
- * Pulsing Border Pattern with Smoke Effect
- * This shader creates a rounded border mask with multiple color spots
- * traveling along the border
+ * Color spots traveling around rectangular stroke (border)
+ *
+ * Uniforms:
+ * - u_colorBack (RGBA)
+ * - u_colors (vec4[]), u_colorsCount (float used as integer)
+ * - u_roundness, u_thickness, u_softness: border parameters
+ * - u_intensity: global multiplier for spots shape & color
+ * - u_spotSize: angular size of spots
+ * - u_spotsPerColor (float used as int): number of spots rendered per color (not all visible at the same time)
+ * - u_pulse: optional pulsing animation
+ * - u_smoke, u_smokeSize: optional noisy shapes around the border
+ *
+ * - u_pulseTexture (sampler2D): pulsing signal source
+ * - u_noiseTexture (sampler2D): pre-computed randomizer source
  *
- * Uniforms include:
- * u_colorBack   - The background color of the pattern
- * u_colors      - An array of colors for the pulsing spots (with up to `u_colorsCount` entries)
- * u_colorsCount - The number of colors used in the pattern
- * u_roundness   - The roundness of the border corners
- * u_thickness   - The thickness of the border
- * u_softness    - The blur around the border edges
- * u_intensity   - The intensity multiplier for the pulsing effect
- * u_spotSize    - The size of the color spots
- * u_spotsPerColor - The number of spots for each color (not all the spots are visible all the time)
- * u_pulse     - A multiplier for the pulsing strength (pulsing signal taken from the u_pulseTexture)
- * u_smoke       - The strength of the smoke effect (the noise aroung the border)
  */
 export declare const pulsingBorderFragmentShader: string;
 export interface PulsingBorderUniforms extends ShaderSizingUniforms {

package/dist/shaders/pulsing-border.js

@@ -0,0 +1,211 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+import { sizingVariablesDeclaration } from "../shader-sizing.js";
+import { declarePI, declareValueNoise, colorBandingFix } from "../shader-utils.js";
+const pulsingBorderMeta = {
+  maxColorCount: 5,
+  maxSpotsPerColor: 5
+};
+const pulsingBorderFragmentShader = `#version 300 es
+precision lowp float;
+
+uniform float u_time;
+
+uniform vec4 u_colorBack;
+uniform vec4 u_colors[${pulsingBorderMeta.maxColorCount}];
+uniform float u_colorsCount;
+uniform float u_roundness;
+uniform float u_thickness;
+uniform float u_softness;
+uniform float u_intensity;
+uniform float u_spotSize;
+uniform float u_spotsPerColor;
+uniform float u_pulse;
+uniform float u_smoke;
+uniform float u_smokeSize;
+
+uniform sampler2D u_pulseTexture;
+uniform sampler2D u_noiseTexture;
+
+${sizingVariablesDeclaration}
+
+out vec4 fragColor;
+
+${declarePI}
+
+float roundedBox(vec2 uv, vec2 halfSize, float radius, float distance, float edgeSoftness) {
+    
+    float borderDistance = abs(distance) - .5 * u_thickness;
+    float border = 1. - smoothstep(-.5 * edgeSoftness, .5 * edgeSoftness, borderDistance);
+    border *= border;
+
+    vec2 v0 = uv + halfSize;
+    vec2 v1 = uv - vec2(-halfSize.x, halfSize.y);
+    vec2 v2 = uv - vec2(halfSize.x, -halfSize.y);
+    vec2 v3 = uv - halfSize;
+
+    float mult = (.07 - .25 * radius);
+    float m0 = mult * clamp(pow(1. - abs(v0.x - v0.y), 20.), 0., 1.);
+    float m1 = mult * clamp(pow(1. - abs(v1.x + v1.y), 20.), 0., 1.);
+    float m2 = mult * clamp(pow(1. - abs(v2.x + v2.y), 20.), 0., 1.);
+    float m3 = mult * clamp(pow(1. - abs(v3.x - v3.y), 20.), 0., 1.);
+
+    float l = edgeSoftness * .5 + .75 * u_thickness;
+    float fade0 = 1. - clamp(length(v0) / l, 0., 1.);
+    float fade1 = 1. - clamp(length(v1) / l, 0., 1.);
+    float fade2 = 1. - clamp(length(v2) / l, 0., 1.);
+    float fade3 = 1. - clamp(length(v3) / l, 0., 1.);
+
+    m0 *= fade0;
+    m1 *= fade1;
+    m2 *= fade2;
+    m3 *= fade3;
+
+    float fillFix = m0 + m1 + m2 + m3;
+    fillFix *= step(distance, 0.);
+    fillFix *= (1. + 3. * u_thickness);
+    fillFix *= (1.5 - .5 * smoothstep(0., .5, edgeSoftness));
+    fillFix = clamp(fillFix, 0., 1.);
+
+    return border + fillFix;
+}
+
+float roundedBoxSmoke(vec2 uv, vec2 halfSize, float radius, float distance, float size) {
+    float borderDistance = abs(distance);
+    float border = 1. - smoothstep(-.75 * size, .75 * size, borderDistance);
+    border *= border;
+
+    vec2 v0 = uv + halfSize;
+    vec2 v1 = uv - vec2(-halfSize.x, halfSize.y);
+    vec2 v2 = uv - vec2(halfSize.x, -halfSize.y);
+    vec2 v3 = uv - halfSize;
+
+    float l_mask = .5;
+    float mask = smoothstep(0., 1., length(v0) / l_mask);
+    mask *= smoothstep(0., 1., length(v1) / l_mask);
+    mask *= smoothstep(0., 1., length(v2) / l_mask);
+    mask *= smoothstep(0., 1., length(v3) / l_mask);
+
+    return border * mask;
+}
+
+float random(vec2 p) {
+  vec2 uv = floor(p) / 100. + .5;
+  return texture(u_noiseTexture, uv).g;
+}
+vec2 rand2(vec2 p) {
+  vec2 uv = floor(p) / 100. + .5;
+  return texture(u_noiseTexture, uv).gb;
+}
+
+${declareValueNoise}
+
+float getWaveformValue(float time) {
+  float dur = 5.;
+  float wrappedTime = mod(time, dur);
+  float normalizedTime = wrappedTime / dur;
+  float value = texture(u_pulseTexture, vec2(normalizedTime, 0.5)).r;
+  return value * 2. - 1.;
+}
+
+void main() {
+
+  float t = .5 * u_time + 20.;
+
+  vec2 borderUV = v_responsiveUV;
+
+  float angle = atan(borderUV.y, borderUV.x) / TWO_PI;
+
+
+  float borderRatio = v_responsiveBoxGivenSize.x / v_responsiveBoxGivenSize.y;
+  borderUV.x *= borderRatio;
+  vec2 halfSize = vec2(.5);
+  halfSize.x *= borderRatio;
+  float radius = min(.5 * u_roundness, halfSize.x);
+  vec2 d = abs(borderUV) - halfSize + radius;
+  float outsideDistance = length(max(d, 0.)) - radius;
+  float insideDistance = min(max(d.x, d.y), 0.0);
+  float distance = outsideDistance + insideDistance;
+
+  float border = roundedBox(borderUV, halfSize, radius, distance, .5 * u_softness);
+
+  float pulse = u_pulse * getWaveformValue(.18 * u_time);
+
+  border *= (1. + .1 * pulse);
+  border *= (1. + u_intensity);
+
+  vec2 smokeUV = .001 * u_smokeSize * v_patternUV;
+  float smoke = clamp(3. * valueNoise(2.7 * smokeUV + .5 * t), 0., 1.);
+  smoke -= valueNoise(3.4 * smokeUV - .5 * t);
+  smoke *= roundedBoxSmoke(borderUV, halfSize, radius, distance, u_smoke);
+  smoke = 50. * pow(smoke, 2.);
+  smoke *= u_smoke;
+  smoke *= (.8 + .4 * pulse);
+  smoke = clamp(smoke, 0., 1.);
+
+  border += smoke;
+
+  float sectorsTotal = 0.;
+
+  vec3 color = vec3(0.);
+  float opacity = 0.;
+
+  vec3 accumColor = vec3(0.);
+  float accumAlpha = 0.;
+
+  for (int i = 0; i < ${pulsingBorderMeta.maxSpotsPerColor}; i++) {
+    if (i >= int(u_spotsPerColor)) break;
+    float idx = float(i);
+
+    for (int j = 0; j < ${pulsingBorderMeta.maxColorCount}; j++) {
+      if (j >= int(u_colorsCount)) break;
+      float colorIdx = float(j);
+
+      vec2 randVal = rand2(vec2(idx * 10. + 2., 40. + colorIdx));
+  
+      float time = (.1 + .15 * abs(sin(idx * (2. + colorIdx)) * cos(idx * (2. + 2.5 * colorIdx)))) * t + randVal.x * 3.;
+      time *= mix(1., -1., step(.5, randVal.y));
+
+      float mask = .2 + mix(
+        sin(t + idx * (5. - 1.5 * colorIdx)),
+        cos(t + idx * (3. + 1.3 * colorIdx)),
+        step(mod(colorIdx, 2.), .5)
+      );
+
+      mask += pulse;
+      if (mask < 0.) continue;
+
+      float atg1 = fract(angle + time);
+      float sector = smoothstep(.5 - u_spotSize, .5, atg1) * smoothstep(.5 + u_spotSize, .5, atg1);
+      sector *= border;
+      sector *= mask;
+      sector = clamp(sector, 0., 1.);
+
+      sectorsTotal += sector;
+
+      float alpha = sector * u_colors[j].a;
+      accumColor += u_colors[j].rgb * alpha;
+      accumAlpha += alpha;
+    }
+  }
+
+  color = accumColor;
+  opacity = clamp(accumAlpha, 0., 1.);
+
+  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;
+  color = color + bgColor * (1. - opacity);
+  opacity = opacity + u_colorBack.a * (1. - opacity);
+
+  ${colorBandingFix}
+
+  fragColor = vec4(color, opacity);
+}
+`;
+export {
+  pulsingBorderFragmentShader,
+  pulsingBorderMeta
+};
+//# sourceMappingURL=pulsing-border.js.map