@clypra-studio/shaders 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,23 @@
+
+> @clypra-studio/shaders@0.1.0 build /home/runner/work/clypra-studio/clypra-studio/packages/shaders
+> tsup
+
+CLI Building entry: {"index":"src/index.ts","utils/index":"src/utils/index.ts","noise/index":"src/noise/index.ts"}
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/clypra-studio/clypra-studio/packages/shaders/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+ESM dist/index.js           5.42 KB
+ESM dist/utils/index.js     2.32 KB
+ESM dist/noise/index.js     3.13 KB
+ESM dist/index.js.map       7.99 KB
+ESM dist/utils/index.js.map 3.17 KB
+ESM dist/noise/index.js.map 4.33 KB
+ESM ⚡️ Build success in 358ms
+DTS Build start
+DTS ⚡️ Build success in 4708ms
+DTS dist/index.d.ts       482.00 B
+DTS dist/noise/index.d.ts 3.43 KB
+DTS dist/utils/index.d.ts 2.51 KB

package/.turbo/turbo-lint.log

@@ -0,0 +1,4 @@
+
+> @clypra-studio/shaders@0.1.0 lint /home/runner/work/clypra-studio/clypra-studio/packages/shaders
+> tsc --noEmit
+

package/.turbo/turbo-test.log

@@ -0,0 +1,13 @@
+
+> @clypra-studio/shaders@0.1.0 test /home/runner/work/clypra-studio/clypra-studio/packages/shaders
+> vitest run
+
+
+ RUN  v3.2.6 /home/runner/work/clypra-studio/clypra-studio/packages/shaders
+
+No test files found, exiting with code 1
+
+include: **/*.{test,spec}.?(c|m)[jt]s?(x)
+exclude:  **/node_modules/**, **/dist/**, **/cypress/**, **/.{idea,git,cache,output,temp}/**, **/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*
+
+ ELIFECYCLE  Test failed. See above for more details.

package/.turbo/turbo-typecheck.log

@@ -0,0 +1,4 @@
+
+> @clypra-studio/shaders@0.1.0 typecheck /home/runner/work/clypra-studio/clypra-studio/packages/shaders
+> tsc --noEmit
+

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @clypra-studio/shaders
+
+## 0.1.0
+
+### Minor Changes
+
+- 2c117a9: Renamed package from @clypra-studio/shader-library to @clypra-studio/shaders
+
+  This is the initial release of @clypra-studio/shaders at 0.1.0, replacing the deprecated @clypra-studio/shader-library package.

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Abdulkabir Musa(AIEraDev)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# @clypra-studio/shaders
+
+Reusable GLSL shader library for video effects. A collection of high-performance shaders for common video processing tasks.
+
+## Installation
+
+```bash
+npm install @clypra-studio/shaders
+# or
+pnpm add @clypra-studio/shaders
+# or
+yarn add @clypra-studio/shaders
+```
+
+## Usage
+
+```typescript
+import { createShader } from "@clypra-studio/shaders";
+import { BlurShader } from "@clypra-studio/shaders/blur";
+import { ColorShader } from "@clypra-studio/shaders/color";
+import { NoiseShader } from "@clypra-studio/shaders/noise";
+import { shaderUtils } from "@clypra-studio/shaders/utils";
+
+// Use a pre-built shader
+const blurShader = BlurShader.create({ radius: 10 });
+
+// Combine shaders
+const composite = shaderUtils.compose(ColorShader.saturation(1.2), BlurShader.gaussian(5));
+```
+
+## Features
+
+- ✅ **Color Effects** - Saturation, hue, brightness, contrast
+- ✅ **Blur Effects** - Gaussian, box, and directional blur
+- ✅ **Distortion** - Warp, ripple, and displacement effects
+- ✅ **Noise** - Perlin, simplex, and cellular noise
+- ✅ **Composite** - Blend modes and compositing operations
+- ✅ **Utils** - Shader composition and common utilities
+- ✅ **TypeScript** - Full type definitions
+- ✅ **Tree-shakeable** - Import only what you need
+
+## Available Shaders
+
+### Color Shaders (`/color`)
+
+- Saturation adjustment
+- Hue rotation
+- Brightness control
+- Contrast adjustment
+- Color grading
+
+### Blur Shaders (`/blur`)
+
+- Gaussian blur
+- Box blur
+- Directional blur
+- Radial blur
+
+### Distortion Shaders (`/distortion`)
+
+- Warp effects
+- Ripple effects
+- Displacement mapping
+
+### Noise Shaders (`/noise`)
+
+- Perlin noise
+- Simplex noise
+- Cellular noise
+- Fractal noise
+
+### Composite Shaders (`/composite`)
+
+- Blend modes (multiply, screen, overlay, etc.)
+- Alpha compositing
+- Masking operations
+
+### Utilities (`/utils`)
+
+- Shader composition helpers
+- Common GLSL functions
+- Coordinate transformations
+
+## Entry Points
+
+- **`@clypra-studio/shaders`** - Main exports
+- **`@clypra-studio/shaders/color`** - Color effects
+- **`@clypra-studio/shaders/blur`** - Blur effects
+- **`@clypra-studio/shaders/distortion`** - Distortion effects
+- **`@clypra-studio/shaders/composite`** - Compositing operations
+- **`@clypra-studio/shaders/noise`** - Noise generators
+- **`@clypra-studio/shaders/utils`** - Utilities and helpers
+
+## License
+
+MIT
+
+## Links
+
+- [GitHub Repository](https://github.com/AIEraDev/clypra-studio)
+- [Report Issues](https://github.com/AIEraDev/clypra-studio/issues)
+- [npm Package](https://www.npmjs.com/package/@clypra-studio/shaders)
+
+---
+
+> **Note:** This package was previously published as `@clypra-studio/shader-library`. Use `@clypra-studio/shaders` for new projects.

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { createFragmentShader, glslUtils, standardVertexShader } from './utils/index.js';
+export { cellularNoiseShader, filmGrainShader, noiseShaders, perlinNoiseShader, simplexNoiseShader } from './noise/index.js';
+
+/**
+ * @clypra/shader-library
+ *
+ * Reusable GLSL shader library for video effects.
+ * All shaders are organized by category for easy reuse across effects.
+ *
+ * @packageDocumentation
+ */
+/** Package version */
+declare const VERSION = "0.1.0";
+
+export { VERSION };

package/dist/index.js

@@ -0,0 +1,247 @@
+// src/utils/index.ts
+var glslUtils = `
+// Hash function for random number generation
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+// 2D noise function
+float noise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  
+  f = f * f * (3.0 - 2.0 * f);
+  
+  float a = hash(i);
+  float b = hash(i + vec2(1.0, 0.0));
+  float c = hash(i + vec2(0.0, 1.0));
+  float d = hash(i + vec2(1.0, 1.0));
+  
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+
+// Smooth minimum
+float smin(float a, float b, float k) {
+  float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
+  return mix(b, a, h) - k * h * (1.0 - h);
+}
+
+// Smooth step with adjustable edge
+float smootherstep(float edge0, float edge1, float x) {
+  x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+  return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);
+}
+
+// Luminance calculation
+float luminance(vec3 color) {
+  return dot(color, vec3(0.299, 0.587, 0.114));
+}
+
+// RGB to HSV
+vec3 rgb2hsv(vec3 c) {
+  vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+  
+  float d = q.x - min(q.w, q.y);
+  float e = 1.0e-10;
+  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+// HSV to RGB
+vec3 hsv2rgb(vec3 c) {
+  vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+// Vignette effect
+float vignette(vec2 uv, float intensity, float extent) {
+  vec2 center = uv * 2.0 - 1.0;
+  float dist = length(center);
+  return 1.0 - smoothstep(extent, extent + intensity, dist);
+}
+
+// Posterize
+vec3 posterize(vec3 color, float levels) {
+  return floor(color * levels) / levels;
+}
+`;
+function createFragmentShader(mainCode) {
+  return `
+precision highp float;
+
+varying vec2 vTextureCoord;
+
+${glslUtils}
+
+${mainCode}
+`;
+}
+var standardVertexShader = `
+attribute vec2 aVertexPosition;
+attribute vec2 aTextureCoord;
+
+uniform mat3 projectionMatrix;
+
+varying vec2 vTextureCoord;
+
+void main() {
+  gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
+  vTextureCoord = aTextureCoord;
+}
+`;
+
+// src/noise/index.ts
+var filmGrainShader = `
+uniform sampler2D uTexture;
+uniform float uIntensity;
+uniform float uSize;
+uniform float uTime;
+
+float filmGrain(vec2 uv, float time) {
+  vec2 p = uv * uSize;
+  p += time * 1000.0;
+  
+  float n = hash(p);
+  n = n * 2.0 - 1.0;
+  
+  return n * uIntensity;
+}
+
+void main() {
+  vec2 uv = vTextureCoord;
+  vec4 color = texture2D(uTexture, uv);
+  
+  float grain = filmGrain(uv, uTime);
+  color.rgb += grain;
+  
+  gl_FragColor = color;
+}
+`;
+var perlinNoiseShader = `
+vec2 fade(vec2 t) {
+  return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+}
+
+float perlinNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  
+  vec2 u = fade(f);
+  
+  float a = hash(i);
+  float b = hash(i + vec2(1.0, 0.0));
+  float c = hash(i + vec2(0.0, 1.0));
+  float d = hash(i + vec2(1.0, 1.0));
+  
+  return mix(
+    mix(a, b, u.x),
+    mix(c, d, u.x),
+    u.y
+  );
+}
+
+float fbm(vec2 p) {
+  float value = 0.0;
+  float amplitude = 0.5;
+  float frequency = 1.0;
+  
+  for (int i = 0; i < 5; i++) {
+    value += amplitude * perlinNoise(p * frequency);
+    amplitude *= 0.5;
+    frequency *= 2.0;
+  }
+  
+  return value;
+}
+`;
+var simplexNoiseShader = `
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+  return mod289(((x * 34.0) + 1.0) * x);
+}
+
+float simplexNoise(vec2 v) {
+  const vec4 C = vec4(
+    0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+    0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+    -0.577350269189626, // -1.0 + 2.0 * C.x
+    0.024390243902439   // 1.0 / 41.0
+  );
+
+  vec2 i = floor(v + dot(v, C.yy));
+  vec2 x0 = v - i + dot(i, C.xx);
+
+  vec2 i1;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+  i = mod289(i);
+  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))
+    + i.x + vec3(0.0, i1.x, 1.0));
+
+  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+  m = m * m;
+  m = m * m;
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+
+  vec3 g;
+  g.x = a0.x * x0.x + h.x * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+`;
+var cellularNoiseShader = `
+vec2 random2(vec2 p) {
+  return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))) * 43758.5453);
+}
+
+float cellularNoise(vec2 p) {
+  vec2 i_p = floor(p);
+  vec2 f_p = fract(p);
+  
+  float minDist = 1.0;
+  
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 neighbor = vec2(float(x), float(y));
+      vec2 point = random2(i_p + neighbor);
+      
+      vec2 diff = neighbor + point - f_p;
+      float dist = length(diff);
+      
+      minDist = min(minDist, dist);
+    }
+  }
+  
+  return minDist;
+}
+`;
+var noiseShaders = {
+  filmGrain: filmGrainShader,
+  perlin: perlinNoiseShader,
+  simplex: simplexNoiseShader,
+  cellular: cellularNoiseShader
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+export { VERSION, cellularNoiseShader, createFragmentShader, filmGrainShader, glslUtils, noiseShaders, perlinNoiseShader, simplexNoiseShader, standardVertexShader };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/index.ts","../src/noise/index.ts","../src/index.ts"],"names":[],"mappings":";AASO,IAAM,SAAA,GAAY;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;AAwElB,SAAS,qBAAqB,QAAA,EAA0B;AAC7D,EAAA,OAAO;AAAA;;AAAA;;AAAA,EAKP,SAAS;;AAAA,EAET,QAAQ;AAAA,CAAA;AAEV;AAKO,IAAM,oBAAA,GAAuB;AAAA;AAAA;;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACvF7B,IAAM,eAAA,GAAkB;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA8BxB,IAAM,iBAAA,GAAoB;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;AAyC1B,IAAM,kBAAA,GAAqB;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;AAsD3B,IAAM,mBAAA,GAAsB;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2B5B,IAAM,YAAA,GAAe;AAAA,EAC1B,SAAA,EAAW,eAAA;AAAA,EACX,MAAA,EAAQ,iBAAA;AAAA,EACR,OAAA,EAAS,kBAAA;AAAA,EACT,QAAA,EAAU;AACZ;;;AC5JO,IAAM,OAAA,GAAU","file":"index.js","sourcesContent":["/**\n * @clypra/shader-library — GLSL Utility Functions\n *\n * Common utility functions used across shaders\n */\n\n/**\n * Common GLSL utility functions as a string\n */\nexport const glslUtils = `\n// Hash function for random number generation\nfloat hash(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);\n}\n\n// 2D noise function\nfloat noise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  \n  f = f * f * (3.0 - 2.0 * f);\n  \n  float a = hash(i);\n  float b = hash(i + vec2(1.0, 0.0));\n  float c = hash(i + vec2(0.0, 1.0));\n  float d = hash(i + vec2(1.0, 1.0));\n  \n  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\n// Smooth minimum\nfloat smin(float a, float b, float k) {\n  float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);\n  return mix(b, a, h) - k * h * (1.0 - h);\n}\n\n// Smooth step with adjustable edge\nfloat smootherstep(float edge0, float edge1, float x) {\n  x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n  return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);\n}\n\n// Luminance calculation\nfloat luminance(vec3 color) {\n  return dot(color, vec3(0.299, 0.587, 0.114));\n}\n\n// RGB to HSV\nvec3 rgb2hsv(vec3 c) {\n  vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n  \n  float d = q.x - min(q.w, q.y);\n  float e = 1.0e-10;\n  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n}\n\n// HSV to RGB\nvec3 hsv2rgb(vec3 c) {\n  vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n}\n\n// Vignette effect\nfloat vignette(vec2 uv, float intensity, float extent) {\n  vec2 center = uv * 2.0 - 1.0;\n  float dist = length(center);\n  return 1.0 - smoothstep(extent, extent + intensity, dist);\n}\n\n// Posterize\nvec3 posterize(vec3 color, float levels) {\n  return floor(color * levels) / levels;\n}\n`;\n\n/**\n * Create a complete fragment shader with utilities\n */\nexport function createFragmentShader(mainCode: string): string {\n  return `\nprecision highp float;\n\nvarying vec2 vTextureCoord;\n\n${glslUtils}\n\n${mainCode}\n`;\n}\n\n/**\n * Standard vertex shader\n */\nexport const standardVertexShader = `\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main() {\n  gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n  vTextureCoord = aTextureCoord;\n}\n`;\n","/**\n * @clypra/shader-library — Noise Shaders\n *\n * Various noise generation functions for procedural effects\n */\n\n/**\n * Film grain shader\n */\nexport const filmGrainShader = `\nuniform sampler2D uTexture;\nuniform float uIntensity;\nuniform float uSize;\nuniform float uTime;\n\nfloat filmGrain(vec2 uv, float time) {\n  vec2 p = uv * uSize;\n  p += time * 1000.0;\n  \n  float n = hash(p);\n  n = n * 2.0 - 1.0;\n  \n  return n * uIntensity;\n}\n\nvoid main() {\n  vec2 uv = vTextureCoord;\n  vec4 color = texture2D(uTexture, uv);\n  \n  float grain = filmGrain(uv, uTime);\n  color.rgb += grain;\n  \n  gl_FragColor = color;\n}\n`;\n\n/**\n * Perlin noise shader\n */\nexport const perlinNoiseShader = `\nvec2 fade(vec2 t) {\n  return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);\n}\n\nfloat perlinNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  \n  vec2 u = fade(f);\n  \n  float a = hash(i);\n  float b = hash(i + vec2(1.0, 0.0));\n  float c = hash(i + vec2(0.0, 1.0));\n  float d = hash(i + vec2(1.0, 1.0));\n  \n  return mix(\n    mix(a, b, u.x),\n    mix(c, d, u.x),\n    u.y\n  );\n}\n\nfloat fbm(vec2 p) {\n  float value = 0.0;\n  float amplitude = 0.5;\n  float frequency = 1.0;\n  \n  for (int i = 0; i < 5; i++) {\n    value += amplitude * perlinNoise(p * frequency);\n    amplitude *= 0.5;\n    frequency *= 2.0;\n  }\n  \n  return value;\n}\n`;\n\n/**\n * Simplex noise (approximation)\n */\nexport const simplexNoiseShader = `\nvec3 mod289(vec3 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec2 mod289(vec2 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec3 permute(vec3 x) {\n  return mod289(((x * 34.0) + 1.0) * x);\n}\n\nfloat simplexNoise(vec2 v) {\n  const vec4 C = vec4(\n    0.211324865405187,  // (3.0-sqrt(3.0))/6.0\n    0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)\n    -0.577350269189626, // -1.0 + 2.0 * C.x\n    0.024390243902439   // 1.0 / 41.0\n  );\n\n  vec2 i = floor(v + dot(v, C.yy));\n  vec2 x0 = v - i + dot(i, C.xx);\n\n  vec2 i1;\n  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n  vec4 x12 = x0.xyxy + C.xxzz;\n  x12.xy -= i1;\n\n  i = mod289(i);\n  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))\n    + i.x + vec3(0.0, i1.x, 1.0));\n\n  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);\n  m = m * m;\n  m = m * m;\n\n  vec3 x = 2.0 * fract(p * C.www) - 1.0;\n  vec3 h = abs(x) - 0.5;\n  vec3 ox = floor(x + 0.5);\n  vec3 a0 = x - ox;\n\n  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);\n\n  vec3 g;\n  g.x = a0.x * x0.x + h.x * x0.y;\n  g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n  return 130.0 * dot(m, g);\n}\n`;\n\n/**\n * Cellular/Worley noise\n */\nexport const cellularNoiseShader = `\nvec2 random2(vec2 p) {\n  return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))) * 43758.5453);\n}\n\nfloat cellularNoise(vec2 p) {\n  vec2 i_p = floor(p);\n  vec2 f_p = fract(p);\n  \n  float minDist = 1.0;\n  \n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 neighbor = vec2(float(x), float(y));\n      vec2 point = random2(i_p + neighbor);\n      \n      vec2 diff = neighbor + point - f_p;\n      float dist = length(diff);\n      \n      minDist = min(minDist, dist);\n    }\n  }\n  \n  return minDist;\n}\n`;\n\nexport const noiseShaders = {\n  filmGrain: filmGrainShader,\n  perlin: perlinNoiseShader,\n  simplex: simplexNoiseShader,\n  cellular: cellularNoiseShader,\n};\n","/**\n * @clypra/shader-library\n *\n * Reusable GLSL shader library for video effects.\n * All shaders are organized by category for easy reuse across effects.\n *\n * @packageDocumentation\n */\n\n/** Package version */\nexport const VERSION = \"0.1.0\";\n\n// Utilities\nexport * from \"./utils\";\n\n// Noise functions\nexport * from \"./noise\";\n\n// Note: Other shader categories will be added in subsequent phases\n// export * from './color';\n// export * from './blur';\n// export * from './distortion';\n// export * from './composite';\n"]}

package/dist/noise/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @clypra/shader-library — Noise Shaders
+ *
+ * Various noise generation functions for procedural effects
+ */
+/**
+ * Film grain shader
+ */
+declare const filmGrainShader = "\nuniform sampler2D uTexture;\nuniform float uIntensity;\nuniform float uSize;\nuniform float uTime;\n\nfloat filmGrain(vec2 uv, float time) {\n  vec2 p = uv * uSize;\n  p += time * 1000.0;\n  \n  float n = hash(p);\n  n = n * 2.0 - 1.0;\n  \n  return n * uIntensity;\n}\n\nvoid main() {\n  vec2 uv = vTextureCoord;\n  vec4 color = texture2D(uTexture, uv);\n  \n  float grain = filmGrain(uv, uTime);\n  color.rgb += grain;\n  \n  gl_FragColor = color;\n}\n";
+/**
+ * Perlin noise shader
+ */
+declare const perlinNoiseShader = "\nvec2 fade(vec2 t) {\n  return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);\n}\n\nfloat perlinNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  \n  vec2 u = fade(f);\n  \n  float a = hash(i);\n  float b = hash(i + vec2(1.0, 0.0));\n  float c = hash(i + vec2(0.0, 1.0));\n  float d = hash(i + vec2(1.0, 1.0));\n  \n  return mix(\n    mix(a, b, u.x),\n    mix(c, d, u.x),\n    u.y\n  );\n}\n\nfloat fbm(vec2 p) {\n  float value = 0.0;\n  float amplitude = 0.5;\n  float frequency = 1.0;\n  \n  for (int i = 0; i < 5; i++) {\n    value += amplitude * perlinNoise(p * frequency);\n    amplitude *= 0.5;\n    frequency *= 2.0;\n  }\n  \n  return value;\n}\n";
+/**
+ * Simplex noise (approximation)
+ */
+declare const simplexNoiseShader = "\nvec3 mod289(vec3 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec2 mod289(vec2 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec3 permute(vec3 x) {\n  return mod289(((x * 34.0) + 1.0) * x);\n}\n\nfloat simplexNoise(vec2 v) {\n  const vec4 C = vec4(\n    0.211324865405187,  // (3.0-sqrt(3.0))/6.0\n    0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)\n    -0.577350269189626, // -1.0 + 2.0 * C.x\n    0.024390243902439   // 1.0 / 41.0\n  );\n\n  vec2 i = floor(v + dot(v, C.yy));\n  vec2 x0 = v - i + dot(i, C.xx);\n\n  vec2 i1;\n  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n  vec4 x12 = x0.xyxy + C.xxzz;\n  x12.xy -= i1;\n\n  i = mod289(i);\n  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))\n    + i.x + vec3(0.0, i1.x, 1.0));\n\n  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);\n  m = m * m;\n  m = m * m;\n\n  vec3 x = 2.0 * fract(p * C.www) - 1.0;\n  vec3 h = abs(x) - 0.5;\n  vec3 ox = floor(x + 0.5);\n  vec3 a0 = x - ox;\n\n  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);\n\n  vec3 g;\n  g.x = a0.x * x0.x + h.x * x0.y;\n  g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n  return 130.0 * dot(m, g);\n}\n";
+/**
+ * Cellular/Worley noise
+ */
+declare const cellularNoiseShader = "\nvec2 random2(vec2 p) {\n  return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))) * 43758.5453);\n}\n\nfloat cellularNoise(vec2 p) {\n  vec2 i_p = floor(p);\n  vec2 f_p = fract(p);\n  \n  float minDist = 1.0;\n  \n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 neighbor = vec2(float(x), float(y));\n      vec2 point = random2(i_p + neighbor);\n      \n      vec2 diff = neighbor + point - f_p;\n      float dist = length(diff);\n      \n      minDist = min(minDist, dist);\n    }\n  }\n  \n  return minDist;\n}\n";
+declare const noiseShaders: {
+    filmGrain: string;
+    perlin: string;
+    simplex: string;
+    cellular: string;
+};
+
+export { cellularNoiseShader, filmGrainShader, noiseShaders, perlinNoiseShader, simplexNoiseShader };

package/dist/noise/index.js

@@ -0,0 +1,150 @@
+// src/noise/index.ts
+var filmGrainShader = `
+uniform sampler2D uTexture;
+uniform float uIntensity;
+uniform float uSize;
+uniform float uTime;
+
+float filmGrain(vec2 uv, float time) {
+  vec2 p = uv * uSize;
+  p += time * 1000.0;
+  
+  float n = hash(p);
+  n = n * 2.0 - 1.0;
+  
+  return n * uIntensity;
+}
+
+void main() {
+  vec2 uv = vTextureCoord;
+  vec4 color = texture2D(uTexture, uv);
+  
+  float grain = filmGrain(uv, uTime);
+  color.rgb += grain;
+  
+  gl_FragColor = color;
+}
+`;
+var perlinNoiseShader = `
+vec2 fade(vec2 t) {
+  return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+}
+
+float perlinNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  
+  vec2 u = fade(f);
+  
+  float a = hash(i);
+  float b = hash(i + vec2(1.0, 0.0));
+  float c = hash(i + vec2(0.0, 1.0));
+  float d = hash(i + vec2(1.0, 1.0));
+  
+  return mix(
+    mix(a, b, u.x),
+    mix(c, d, u.x),
+    u.y
+  );
+}
+
+float fbm(vec2 p) {
+  float value = 0.0;
+  float amplitude = 0.5;
+  float frequency = 1.0;
+  
+  for (int i = 0; i < 5; i++) {
+    value += amplitude * perlinNoise(p * frequency);
+    amplitude *= 0.5;
+    frequency *= 2.0;
+  }
+  
+  return value;
+}
+`;
+var simplexNoiseShader = `
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+  return mod289(((x * 34.0) + 1.0) * x);
+}
+
+float simplexNoise(vec2 v) {
+  const vec4 C = vec4(
+    0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+    0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+    -0.577350269189626, // -1.0 + 2.0 * C.x
+    0.024390243902439   // 1.0 / 41.0
+  );
+
+  vec2 i = floor(v + dot(v, C.yy));
+  vec2 x0 = v - i + dot(i, C.xx);
+
+  vec2 i1;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+  i = mod289(i);
+  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))
+    + i.x + vec3(0.0, i1.x, 1.0));
+
+  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+  m = m * m;
+  m = m * m;
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+
+  vec3 g;
+  g.x = a0.x * x0.x + h.x * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+`;
+var cellularNoiseShader = `
+vec2 random2(vec2 p) {
+  return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))) * 43758.5453);
+}
+
+float cellularNoise(vec2 p) {
+  vec2 i_p = floor(p);
+  vec2 f_p = fract(p);
+  
+  float minDist = 1.0;
+  
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 neighbor = vec2(float(x), float(y));
+      vec2 point = random2(i_p + neighbor);
+      
+      vec2 diff = neighbor + point - f_p;
+      float dist = length(diff);
+      
+      minDist = min(minDist, dist);
+    }
+  }
+  
+  return minDist;
+}
+`;
+var noiseShaders = {
+  filmGrain: filmGrainShader,
+  perlin: perlinNoiseShader,
+  simplex: simplexNoiseShader,
+  cellular: cellularNoiseShader
+};
+
+export { cellularNoiseShader, filmGrainShader, noiseShaders, perlinNoiseShader, simplexNoiseShader };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/noise/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/noise/index.ts"],"names":[],"mappings":";AASO,IAAM,eAAA,GAAkB;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA8BxB,IAAM,iBAAA,GAAoB;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;AAyC1B,IAAM,kBAAA,GAAqB;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;AAsD3B,IAAM,mBAAA,GAAsB;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2B5B,IAAM,YAAA,GAAe;AAAA,EAC1B,SAAA,EAAW,eAAA;AAAA,EACX,MAAA,EAAQ,iBAAA;AAAA,EACR,OAAA,EAAS,kBAAA;AAAA,EACT,QAAA,EAAU;AACZ","file":"index.js","sourcesContent":["/**\n * @clypra/shader-library — Noise Shaders\n *\n * Various noise generation functions for procedural effects\n */\n\n/**\n * Film grain shader\n */\nexport const filmGrainShader = `\nuniform sampler2D uTexture;\nuniform float uIntensity;\nuniform float uSize;\nuniform float uTime;\n\nfloat filmGrain(vec2 uv, float time) {\n  vec2 p = uv * uSize;\n  p += time * 1000.0;\n  \n  float n = hash(p);\n  n = n * 2.0 - 1.0;\n  \n  return n * uIntensity;\n}\n\nvoid main() {\n  vec2 uv = vTextureCoord;\n  vec4 color = texture2D(uTexture, uv);\n  \n  float grain = filmGrain(uv, uTime);\n  color.rgb += grain;\n  \n  gl_FragColor = color;\n}\n`;\n\n/**\n * Perlin noise shader\n */\nexport const perlinNoiseShader = `\nvec2 fade(vec2 t) {\n  return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);\n}\n\nfloat perlinNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  \n  vec2 u = fade(f);\n  \n  float a = hash(i);\n  float b = hash(i + vec2(1.0, 0.0));\n  float c = hash(i + vec2(0.0, 1.0));\n  float d = hash(i + vec2(1.0, 1.0));\n  \n  return mix(\n    mix(a, b, u.x),\n    mix(c, d, u.x),\n    u.y\n  );\n}\n\nfloat fbm(vec2 p) {\n  float value = 0.0;\n  float amplitude = 0.5;\n  float frequency = 1.0;\n  \n  for (int i = 0; i < 5; i++) {\n    value += amplitude * perlinNoise(p * frequency);\n    amplitude *= 0.5;\n    frequency *= 2.0;\n  }\n  \n  return value;\n}\n`;\n\n/**\n * Simplex noise (approximation)\n */\nexport const simplexNoiseShader = `\nvec3 mod289(vec3 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec2 mod289(vec2 x) {\n  return x - floor(x * (1.0 / 289.0)) * 289.0;\n}\n\nvec3 permute(vec3 x) {\n  return mod289(((x * 34.0) + 1.0) * x);\n}\n\nfloat simplexNoise(vec2 v) {\n  const vec4 C = vec4(\n    0.211324865405187,  // (3.0-sqrt(3.0))/6.0\n    0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)\n    -0.577350269189626, // -1.0 + 2.0 * C.x\n    0.024390243902439   // 1.0 / 41.0\n  );\n\n  vec2 i = floor(v + dot(v, C.yy));\n  vec2 x0 = v - i + dot(i, C.xx);\n\n  vec2 i1;\n  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);\n  vec4 x12 = x0.xyxy + C.xxzz;\n  x12.xy -= i1;\n\n  i = mod289(i);\n  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))\n    + i.x + vec3(0.0, i1.x, 1.0));\n\n  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);\n  m = m * m;\n  m = m * m;\n\n  vec3 x = 2.0 * fract(p * C.www) - 1.0;\n  vec3 h = abs(x) - 0.5;\n  vec3 ox = floor(x + 0.5);\n  vec3 a0 = x - ox;\n\n  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);\n\n  vec3 g;\n  g.x = a0.x * x0.x + h.x * x0.y;\n  g.yz = a0.yz * x12.xz + h.yz * x12.yw;\n  return 130.0 * dot(m, g);\n}\n`;\n\n/**\n * Cellular/Worley noise\n */\nexport const cellularNoiseShader = `\nvec2 random2(vec2 p) {\n  return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))) * 43758.5453);\n}\n\nfloat cellularNoise(vec2 p) {\n  vec2 i_p = floor(p);\n  vec2 f_p = fract(p);\n  \n  float minDist = 1.0;\n  \n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 neighbor = vec2(float(x), float(y));\n      vec2 point = random2(i_p + neighbor);\n      \n      vec2 diff = neighbor + point - f_p;\n      float dist = length(diff);\n      \n      minDist = min(minDist, dist);\n    }\n  }\n  \n  return minDist;\n}\n`;\n\nexport const noiseShaders = {\n  filmGrain: filmGrainShader,\n  perlin: perlinNoiseShader,\n  simplex: simplexNoiseShader,\n  cellular: cellularNoiseShader,\n};\n"]}

package/dist/utils/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @clypra/shader-library — GLSL Utility Functions
+ *
+ * Common utility functions used across shaders
+ */
+/**
+ * Common GLSL utility functions as a string
+ */
+declare const glslUtils = "\n// Hash function for random number generation\nfloat hash(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);\n}\n\n// 2D noise function\nfloat noise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  \n  f = f * f * (3.0 - 2.0 * f);\n  \n  float a = hash(i);\n  float b = hash(i + vec2(1.0, 0.0));\n  float c = hash(i + vec2(0.0, 1.0));\n  float d = hash(i + vec2(1.0, 1.0));\n  \n  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\n// Smooth minimum\nfloat smin(float a, float b, float k) {\n  float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);\n  return mix(b, a, h) - k * h * (1.0 - h);\n}\n\n// Smooth step with adjustable edge\nfloat smootherstep(float edge0, float edge1, float x) {\n  x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n  return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);\n}\n\n// Luminance calculation\nfloat luminance(vec3 color) {\n  return dot(color, vec3(0.299, 0.587, 0.114));\n}\n\n// RGB to HSV\nvec3 rgb2hsv(vec3 c) {\n  vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n  \n  float d = q.x - min(q.w, q.y);\n  float e = 1.0e-10;\n  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n}\n\n// HSV to RGB\nvec3 hsv2rgb(vec3 c) {\n  vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n}\n\n// Vignette effect\nfloat vignette(vec2 uv, float intensity, float extent) {\n  vec2 center = uv * 2.0 - 1.0;\n  float dist = length(center);\n  return 1.0 - smoothstep(extent, extent + intensity, dist);\n}\n\n// Posterize\nvec3 posterize(vec3 color, float levels) {\n  return floor(color * levels) / levels;\n}\n";
+/**
+ * Create a complete fragment shader with utilities
+ */
+declare function createFragmentShader(mainCode: string): string;
+/**
+ * Standard vertex shader
+ */
+declare const standardVertexShader = "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main() {\n  gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n  vTextureCoord = aTextureCoord;\n}\n";
+
+export { createFragmentShader, glslUtils, standardVertexShader };

package/dist/utils/index.js

@@ -0,0 +1,97 @@
+// src/utils/index.ts
+var glslUtils = `
+// Hash function for random number generation
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+// 2D noise function
+float noise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  
+  f = f * f * (3.0 - 2.0 * f);
+  
+  float a = hash(i);
+  float b = hash(i + vec2(1.0, 0.0));
+  float c = hash(i + vec2(0.0, 1.0));
+  float d = hash(i + vec2(1.0, 1.0));
+  
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+
+// Smooth minimum
+float smin(float a, float b, float k) {
+  float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
+  return mix(b, a, h) - k * h * (1.0 - h);
+}
+
+// Smooth step with adjustable edge
+float smootherstep(float edge0, float edge1, float x) {
+  x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+  return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);
+}
+
+// Luminance calculation
+float luminance(vec3 color) {
+  return dot(color, vec3(0.299, 0.587, 0.114));
+}
+
+// RGB to HSV
+vec3 rgb2hsv(vec3 c) {
+  vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+  
+  float d = q.x - min(q.w, q.y);
+  float e = 1.0e-10;
+  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+// HSV to RGB
+vec3 hsv2rgb(vec3 c) {
+  vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+// Vignette effect
+float vignette(vec2 uv, float intensity, float extent) {
+  vec2 center = uv * 2.0 - 1.0;
+  float dist = length(center);
+  return 1.0 - smoothstep(extent, extent + intensity, dist);
+}
+
+// Posterize
+vec3 posterize(vec3 color, float levels) {
+  return floor(color * levels) / levels;
+}
+`;
+function createFragmentShader(mainCode) {
+  return `
+precision highp float;
+
+varying vec2 vTextureCoord;
+
+${glslUtils}
+
+${mainCode}
+`;
+}
+var standardVertexShader = `
+attribute vec2 aVertexPosition;
+attribute vec2 aTextureCoord;
+
+uniform mat3 projectionMatrix;
+
+varying vec2 vTextureCoord;
+
+void main() {
+  gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
+  vTextureCoord = aTextureCoord;
+}
+`;
+
+export { createFragmentShader, glslUtils, standardVertexShader };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/index.ts"],"names":[],"mappings":";AASO,IAAM,SAAA,GAAY;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;AAwElB,SAAS,qBAAqB,QAAA,EAA0B;AAC7D,EAAA,OAAO;AAAA;;AAAA;;AAAA,EAKP,SAAS;;AAAA,EAET,QAAQ;AAAA,CAAA;AAEV;AAKO,IAAM,oBAAA,GAAuB;AAAA;AAAA;;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA","file":"index.js","sourcesContent":["/**\n * @clypra/shader-library — GLSL Utility Functions\n *\n * Common utility functions used across shaders\n */\n\n/**\n * Common GLSL utility functions as a string\n */\nexport const glslUtils = `\n// Hash function for random number generation\nfloat hash(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);\n}\n\n// 2D noise function\nfloat noise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  \n  f = f * f * (3.0 - 2.0 * f);\n  \n  float a = hash(i);\n  float b = hash(i + vec2(1.0, 0.0));\n  float c = hash(i + vec2(0.0, 1.0));\n  float d = hash(i + vec2(1.0, 1.0));\n  \n  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\n\n// Smooth minimum\nfloat smin(float a, float b, float k) {\n  float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);\n  return mix(b, a, h) - k * h * (1.0 - h);\n}\n\n// Smooth step with adjustable edge\nfloat smootherstep(float edge0, float edge1, float x) {\n  x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n  return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);\n}\n\n// Luminance calculation\nfloat luminance(vec3 color) {\n  return dot(color, vec3(0.299, 0.587, 0.114));\n}\n\n// RGB to HSV\nvec3 rgb2hsv(vec3 c) {\n  vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n  \n  float d = q.x - min(q.w, q.y);\n  float e = 1.0e-10;\n  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n}\n\n// HSV to RGB\nvec3 hsv2rgb(vec3 c) {\n  vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n}\n\n// Vignette effect\nfloat vignette(vec2 uv, float intensity, float extent) {\n  vec2 center = uv * 2.0 - 1.0;\n  float dist = length(center);\n  return 1.0 - smoothstep(extent, extent + intensity, dist);\n}\n\n// Posterize\nvec3 posterize(vec3 color, float levels) {\n  return floor(color * levels) / levels;\n}\n`;\n\n/**\n * Create a complete fragment shader with utilities\n */\nexport function createFragmentShader(mainCode: string): string {\n  return `\nprecision highp float;\n\nvarying vec2 vTextureCoord;\n\n${glslUtils}\n\n${mainCode}\n`;\n}\n\n/**\n * Standard vertex shader\n */\nexport const standardVertexShader = `\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main() {\n  gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n  vTextureCoord = aTextureCoord;\n}\n`;\n"]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@clypra-studio/shaders",
+  "version": "0.1.0",
+  "description": "Reusable GLSL shader library for video effects",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./color": "./dist/color/index.js",
+    "./blur": "./dist/blur/index.js",
+    "./distortion": "./dist/distortion/index.js",
+    "./composite": "./dist/composite/index.js",
+    "./noise": "./dist/noise/index.js",
+    "./utils": "./dist/utils/index.js"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "tsup": "^8.3.5",
+    "typescript": "~5.8.2",
+    "vitest": "^3.2.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AIEraDev/clypra-studio.git",
+    "directory": "packages/shader-library"
+  },
+  "homepage": "https://github.com/AIEraDev/clypra-studio/tree/main/packages/shader-library#readme",
+  "bugs": {
+    "url": "https://github.com/AIEraDev/clypra-studio/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+/**
+ * @clypra/shader-library
+ *
+ * Reusable GLSL shader library for video effects.
+ * All shaders are organized by category for easy reuse across effects.
+ *
+ * @packageDocumentation
+ */
+
+/** Package version */
+export const VERSION = "0.1.0";
+
+// Utilities
+export * from "./utils";
+
+// Noise functions
+export * from "./noise";
+
+// Note: Other shader categories will be added in subsequent phases
+// export * from './color';
+// export * from './blur';
+// export * from './distortion';
+// export * from './composite';

package/src/noise/index.ts

@@ -0,0 +1,167 @@
+/**
+ * @clypra/shader-library — Noise Shaders
+ *
+ * Various noise generation functions for procedural effects
+ */
+
+/**
+ * Film grain shader
+ */
+export const filmGrainShader = `
+uniform sampler2D uTexture;
+uniform float uIntensity;
+uniform float uSize;
+uniform float uTime;
+
+float filmGrain(vec2 uv, float time) {
+  vec2 p = uv * uSize;
+  p += time * 1000.0;
+  
+  float n = hash(p);
+  n = n * 2.0 - 1.0;
+  
+  return n * uIntensity;
+}
+
+void main() {
+  vec2 uv = vTextureCoord;
+  vec4 color = texture2D(uTexture, uv);
+  
+  float grain = filmGrain(uv, uTime);
+  color.rgb += grain;
+  
+  gl_FragColor = color;
+}
+`;
+
+/**
+ * Perlin noise shader
+ */
+export const perlinNoiseShader = `
+vec2 fade(vec2 t) {
+  return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+}
+
+float perlinNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  
+  vec2 u = fade(f);
+  
+  float a = hash(i);
+  float b = hash(i + vec2(1.0, 0.0));
+  float c = hash(i + vec2(0.0, 1.0));
+  float d = hash(i + vec2(1.0, 1.0));
+  
+  return mix(
+    mix(a, b, u.x),
+    mix(c, d, u.x),
+    u.y
+  );
+}
+
+float fbm(vec2 p) {
+  float value = 0.0;
+  float amplitude = 0.5;
+  float frequency = 1.0;
+  
+  for (int i = 0; i < 5; i++) {
+    value += amplitude * perlinNoise(p * frequency);
+    amplitude *= 0.5;
+    frequency *= 2.0;
+  }
+  
+  return value;
+}
+`;
+
+/**
+ * Simplex noise (approximation)
+ */
+export const simplexNoiseShader = `
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+  return mod289(((x * 34.0) + 1.0) * x);
+}
+
+float simplexNoise(vec2 v) {
+  const vec4 C = vec4(
+    0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+    0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+    -0.577350269189626, // -1.0 + 2.0 * C.x
+    0.024390243902439   // 1.0 / 41.0
+  );
+
+  vec2 i = floor(v + dot(v, C.yy));
+  vec2 x0 = v - i + dot(i, C.xx);
+
+  vec2 i1;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+  i = mod289(i);
+  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))
+    + i.x + vec3(0.0, i1.x, 1.0));
+
+  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+  m = m * m;
+  m = m * m;
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+
+  vec3 g;
+  g.x = a0.x * x0.x + h.x * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+`;
+
+/**
+ * Cellular/Worley noise
+ */
+export const cellularNoiseShader = `
+vec2 random2(vec2 p) {
+  return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))) * 43758.5453);
+}
+
+float cellularNoise(vec2 p) {
+  vec2 i_p = floor(p);
+  vec2 f_p = fract(p);
+  
+  float minDist = 1.0;
+  
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 neighbor = vec2(float(x), float(y));
+      vec2 point = random2(i_p + neighbor);
+      
+      vec2 diff = neighbor + point - f_p;
+      float dist = length(diff);
+      
+      minDist = min(minDist, dist);
+    }
+  }
+  
+  return minDist;
+}
+`;
+
+export const noiseShaders = {
+  filmGrain: filmGrainShader,
+  perlin: perlinNoiseShader,
+  simplex: simplexNoiseShader,
+  cellular: cellularNoiseShader,
+};

package/src/utils/index.ts

@@ -0,0 +1,109 @@
+/**
+ * @clypra/shader-library — GLSL Utility Functions
+ *
+ * Common utility functions used across shaders
+ */
+
+/**
+ * Common GLSL utility functions as a string
+ */
+export const glslUtils = `
+// Hash function for random number generation
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+// 2D noise function
+float noise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  
+  f = f * f * (3.0 - 2.0 * f);
+  
+  float a = hash(i);
+  float b = hash(i + vec2(1.0, 0.0));
+  float c = hash(i + vec2(0.0, 1.0));
+  float d = hash(i + vec2(1.0, 1.0));
+  
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+
+// Smooth minimum
+float smin(float a, float b, float k) {
+  float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
+  return mix(b, a, h) - k * h * (1.0 - h);
+}
+
+// Smooth step with adjustable edge
+float smootherstep(float edge0, float edge1, float x) {
+  x = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+  return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);
+}
+
+// Luminance calculation
+float luminance(vec3 color) {
+  return dot(color, vec3(0.299, 0.587, 0.114));
+}
+
+// RGB to HSV
+vec3 rgb2hsv(vec3 c) {
+  vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+  
+  float d = q.x - min(q.w, q.y);
+  float e = 1.0e-10;
+  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+// HSV to RGB
+vec3 hsv2rgb(vec3 c) {
+  vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+// Vignette effect
+float vignette(vec2 uv, float intensity, float extent) {
+  vec2 center = uv * 2.0 - 1.0;
+  float dist = length(center);
+  return 1.0 - smoothstep(extent, extent + intensity, dist);
+}
+
+// Posterize
+vec3 posterize(vec3 color, float levels) {
+  return floor(color * levels) / levels;
+}
+`;
+
+/**
+ * Create a complete fragment shader with utilities
+ */
+export function createFragmentShader(mainCode: string): string {
+  return `
+precision highp float;
+
+varying vec2 vTextureCoord;
+
+${glslUtils}
+
+${mainCode}
+`;
+}
+
+/**
+ * Standard vertex shader
+ */
+export const standardVertexShader = `
+attribute vec2 aVertexPosition;
+attribute vec2 aTextureCoord;
+
+uniform mat3 projectionMatrix;
+
+varying vec2 vTextureCoord;
+
+void main() {
+  gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
+  vTextureCoord = aTextureCoord;
+}
+`;

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+    "utils/index": "src/utils/index.ts",
+    "noise/index": "src/noise/index.ts",
+  },
+  format: ["esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  splitting: false,
+  treeshake: true,
+});