@lovehlmmm/primekit 1.0.0

package/skills/shader/references/glsl-pattern-symmetry-truchet-domain-warping.md

@@ -0,0 +1,134 @@
+# Pattern Symmetry & Advanced Techniques
+
+Advanced pattern generation including symmetry, Truchet tiles, and domain warping.
+
+## Mirror/Reflection
+
+```glsl
+// Mirror horizontally
+vec2 mirrorX(vec2 st) {
+    return vec2(abs(st.x - 0.5) + 0.5, st.y);
+}
+
+// Mirror vertically
+vec2 mirrorY(vec2 st) {
+    return vec2(st.x, abs(st.y - 0.5) + 0.5);
+}
+
+// Kaleidoscope (4-fold symmetry)
+vec2 kaleidoscope(vec2 st) {
+    st -= 0.5;
+    st = abs(st);
+    return st + 0.5;
+}
+```
+
+## N-fold Radial Symmetry
+
+```glsl
+vec2 radialSymmetry(vec2 st, float n) {
+    st -= 0.5;
+    float angle = atan(st.y, st.x);
+    float segment = TWO_PI / n;
+    angle = mod(angle, segment);
+    float r = length(st);
+    return vec2(cos(angle), sin(angle)) * r + 0.5;
+}
+
+// Usage: 6-fold snowflake symmetry
+vec2 sym = radialSymmetry(st, 6.0);
+```
+
+## Truchet Tiles
+
+Random orientation per cell:
+
+```glsl
+float random(vec2 st) {
+    return fract(sin(dot(st, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+float truchet(vec2 st, float n) {
+    st *= n;
+    vec2 idx = floor(st);
+    vec2 local = fract(st);
+
+    // Random rotation per cell (0, 90, 180, 270 degrees)
+    float r = random(idx);
+    if (r < 0.25) local = local;
+    else if (r < 0.5) local = vec2(1.0 - local.y, local.x);
+    else if (r < 0.75) local = 1.0 - local;
+    else local = vec2(local.y, 1.0 - local.x);
+
+    // Draw quarter circles
+    float d1 = length(local);
+    float d2 = length(local - 1.0);
+    return min(abs(d1 - 0.5), abs(d2 - 0.5));
+}
+
+// Usage
+float pattern = 1.0 - smoothstep(0.0, 0.05, truchet(st, 8.0));
+```
+
+## Truchet Variations
+
+```glsl
+// Line-based Truchet
+float truchetLines(vec2 st, float n) {
+    st *= n;
+    vec2 idx = floor(st);
+    vec2 local = fract(st);
+
+    float r = random(idx);
+    if (r > 0.5) local = vec2(local.y, local.x);  // Flip diagonal
+
+    // Diagonal line
+    return abs(local.x - local.y);
+}
+
+// Maze pattern
+float truchetMaze(vec2 st, float n) {
+    st *= n;
+    vec2 idx = floor(st);
+    vec2 local = fract(st) - 0.5;
+
+    float r = random(idx);
+    if (r > 0.5) local.x = -local.x;
+
+    return smoothstep(0.0, 0.1, abs(local.x + local.y));
+}
+```
+
+## Domain Warping
+
+```glsl
+vec2 warp(vec2 st, float a) {
+    return st + vec2(sin(st.y * 10.0), sin(st.x * 10.0)) * a;
+}
+
+vec2 animatedWarp(vec2 st, float t, float a) {
+    return st + vec2(sin(st.y * 5.0 + t), cos(st.x * 5.0 + t * 1.3)) * a;
+}
+```
+
+## Iterative Domain Warping
+
+```glsl
+vec2 iterativeWarp(vec2 st, int iterations) {
+    for (int i = 0; i < iterations; i++) {
+        st = vec2(valueNoise(st), valueNoise(st + 5.0)) * 2.0 - 1.0 + st;
+    }
+    return st;
+}
+```
+
+## Practical Pattern Examples
+
+```glsl
+// Islamic-style pattern
+float islamicPattern(vec2 st, float n) {
+    st = radialSymmetry(st, 8.0);
+    st = tile(st, n);
+    return smoothstep(0.4, 0.41, length(st - 0.5));
+}
+```

package/skills/shader/references/glsl-patterns-tiling-fract-matrices-transformations.md

@@ -0,0 +1,133 @@
+# Patterns in GLSL
+
+Create repeating patterns using tiling and coordinate transformations.
+
+## Basic Tiling with fract()
+
+```glsl
+// Tile space into grid
+vec2 tile(vec2 st, float n) {
+    return fract(st * n);
+}
+
+// Usage: 4x4 grid
+vec2 tiled = tile(st, 4.0);
+```
+
+## Grid with Cell Index
+
+```glsl
+// Get both cell index and position within cell
+vec2 grid(vec2 st, float n, out vec2 cellIndex) {
+    st *= n;
+    cellIndex = floor(st);
+    return fract(st);
+}
+
+// Usage
+vec2 idx;
+vec2 local = grid(st, 4.0, idx);
+```
+
+## Brick Pattern (Offset Rows)
+
+```glsl
+vec2 brickTile(vec2 st, float n) {
+    st *= n;
+    float row = floor(st.y);
+    st.x += mod(row, 2.0) * 0.5;  // Offset odd rows
+    return fract(st);
+}
+```
+
+## Hex Grid
+
+```glsl
+vec2 hexGrid(vec2 st, float scale) {
+    st *= scale;
+    vec2 r = vec2(1.0, 1.73205);  // sqrt(3)
+    vec2 h = r * 0.5;
+    vec2 a = mod(st, r) - h;
+    vec2 b = mod(st - h, r) - h;
+    return dot(a, a) < dot(b, b) ? a : b;
+}
+```
+
+## 2D Rotation Matrix
+
+```glsl
+mat2 rotate2d(float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    return mat2(c, -s, s, c);
+}
+
+// Rotate around center
+vec2 rotateAround(vec2 st, vec2 center, float angle) {
+    return rotate2d(angle) * (st - center) + center;
+}
+```
+
+## Scale Matrix
+
+```glsl
+mat2 scale2d(vec2 scale) {
+    return mat2(scale.x, 0.0, 0.0, scale.y);
+}
+
+vec2 scaleFrom(vec2 st, vec2 center, vec2 s) {
+    return scale2d(s) * (st - center) + center;
+}
+```
+
+## Checkerboard
+
+```glsl
+float checker(vec2 st, float n) {
+    st *= n;
+    vec2 idx = floor(st);
+    return mod(idx.x + idx.y, 2.0);
+}
+```
+
+## Stripes
+
+```glsl
+// Horizontal stripes
+float stripes(float y, float n) {
+    return step(0.5, fract(y * n));
+}
+
+// Diagonal stripes
+float diagonalStripes(vec2 st, float n, float angle) {
+    vec2 rotated = rotate2d(angle) * st;
+    return step(0.5, fract(rotated.x * n));
+}
+```
+
+## Polar Patterns
+
+```glsl
+// Convert to polar for radial patterns
+vec2 toPolar(vec2 st) {
+    vec2 pos = st - 0.5;
+    float r = length(pos) * 2.0;
+    float a = atan(pos.y, pos.x);
+    return vec2(r, a);
+}
+
+// Repeat around center
+float radialRepeat(vec2 st, float n) {
+    vec2 polar = toPolar(st);
+    polar.y = fract(polar.y * n / TWO_PI);
+    return polar.y;
+}
+
+// Spiral
+float spiral(vec2 st, float turns) {
+    vec2 polar = toPolar(st);
+    return fract(polar.x - polar.y * turns / TWO_PI);
+}
+```
+
+See also: `glsl-pattern-symmetry-truchet-domain-warping.md`

package/skills/shader/references/glsl-procedural-textures-clouds-marble-wood-terrain.md

@@ -0,0 +1,144 @@
+# Procedural Textures
+
+Practical texture recipes using fBm and noise. See `glsl-fbm-fractional-brownian-motion-turbulence-octaves.md` for core functions.
+
+## Clouds
+
+```glsl
+vec3 clouds(vec2 st, float time) {
+    float n = fbm(st * 3.0 + vec2(time * 0.1, 0.0));
+    n = smoothstep(0.4, 0.6, n);
+    return mix(vec3(0.4, 0.6, 0.9), vec3(1.0), n);
+}
+```
+
+## Marble
+
+```glsl
+float marble(vec2 st) {
+    float n = fbm(st * 4.0);
+    return sin(st.x * 10.0 + n * 20.0) * 0.5 + 0.5;
+}
+
+vec3 marbleColor(vec2 st) {
+    float v = marble(st);
+    vec3 white = vec3(0.95);
+    vec3 gray = vec3(0.3);
+    return mix(gray, white, v);
+}
+```
+
+## Wood Grain
+
+```glsl
+float wood(vec2 st) {
+    float n = fbm(st * 2.0);
+    float grain = sin((st.x + n * 0.5) * 50.0) * 0.5 + 0.5;
+    return mix(0.3, 0.6, grain);
+}
+
+vec3 woodColor(vec2 st) {
+    float v = wood(st);
+    vec3 light = vec3(0.76, 0.60, 0.42);
+    vec3 dark = vec3(0.44, 0.30, 0.18);
+    return mix(dark, light, v);
+}
+```
+
+## Terrain Height
+
+```glsl
+float terrain(vec2 st) {
+    float h = fbm(st * 2.0);
+    h += ridged(st * 4.0) * 0.5;
+    return h;
+}
+
+vec3 terrainColor(vec2 st) {
+    float h = terrain(st);
+    vec3 water = vec3(0.1, 0.3, 0.5);
+    vec3 sand = vec3(0.76, 0.70, 0.50);
+    vec3 grass = vec3(0.2, 0.5, 0.2);
+    vec3 rock = vec3(0.5, 0.5, 0.5);
+    vec3 snow = vec3(1.0);
+
+    if (h < 0.3) return mix(water, sand, h / 0.3);
+    if (h < 0.5) return mix(sand, grass, (h - 0.3) / 0.2);
+    if (h < 0.7) return mix(grass, rock, (h - 0.5) / 0.2);
+    return mix(rock, snow, (h - 0.7) / 0.3);
+}
+```
+
+## Fire / Smoke
+
+```glsl
+vec3 fire(vec2 st, float time) {
+    vec2 q = st;
+    q.y -= time * 0.5;  // Rise
+
+    float n = turbulence(q * 3.0);
+    n *= smoothstep(1.0, 0.0, st.y);  // Fade at top
+
+    vec3 col = mix(vec3(1.0, 0.0, 0.0), vec3(1.0, 1.0, 0.0), n);
+    return col * n;
+}
+
+vec3 smoke(vec2 st, float time) {
+    vec2 q = st;
+    q.y -= time * 0.2;
+
+    float n = fbm(q * 4.0);
+    n *= smoothstep(1.0, 0.0, st.y);
+
+    return vec3(0.3 + n * 0.3) * n;
+}
+```
+
+## Water Caustics
+
+```glsl
+float caustics(vec2 st, float time) {
+    vec2 p = st * 8.0;
+    float c = 0.0;
+    for (int i = 0; i < 3; i++) {
+        float t = time * (0.5 + float(i) * 0.1);
+        c += abs(sin(p.x + sin(p.y + t)) * sin(p.y + sin(p.x + t * 1.3)));
+        p *= 1.5;
+    }
+    return c / 3.0;
+}
+```
+
+## Lava
+
+```glsl
+vec3 lava(vec2 st, float time) {
+    float n = warpedFbm(st + vec2(time * 0.05));
+    vec3 cold = vec3(0.1, 0.0, 0.0);
+    vec3 hot = vec3(1.0, 0.3, 0.0);
+    vec3 bright = vec3(1.0, 0.9, 0.3);
+    return mix(cold, mix(hot, bright, n), smoothstep(0.3, 0.7, n));
+}
+```
+
+## Grass/Fur
+
+```glsl
+float grass(vec2 st) {
+    float n = fbm(st * 20.0);
+    float blade = smoothstep(0.3, 0.5, n);
+    return blade * (0.8 + fbm(st * 5.0) * 0.2);
+}
+```
+
+## Stone/Rock
+
+```glsl
+vec3 stone(vec2 st) {
+    float n1 = fbm(st * 4.0);
+    float n2 = fbm(st * 8.0 + 5.0) * 0.5;
+    float crack = smoothstep(0.48, 0.52, n1);
+    vec3 base = vec3(0.5 + n2 * 0.2);
+    return mix(base * 0.7, base, crack);
+}
+```

package/skills/shader/references/glsl-shader-builtin-functions-complete-api-reference.md

@@ -0,0 +1,112 @@
+# GLSL Built-in Functions Reference
+
+Complete reference for GLSL ES 1.0 / WebGL functions.
+
+## Trigonometric Functions
+
+| Function | Description | Range |
+|----------|-------------|-------|
+| `sin(x)` | Sine | [-1, 1] |
+| `cos(x)` | Cosine | [-1, 1] |
+| `tan(x)` | Tangent | unbounded |
+| `asin(x)` | Arc sine | [-PI/2, PI/2] |
+| `acos(x)` | Arc cosine | [0, PI] |
+| `atan(y, x)` | Arc tangent (quadrant-aware) | [-PI, PI] |
+| `atan(y_over_x)` | Arc tangent | [-PI/2, PI/2] |
+
+All accept float, vec2, vec3, vec4. Input in radians.
+
+## Exponential Functions
+
+| Function | Description |
+|----------|-------------|
+| `pow(x, y)` | x raised to power y |
+| `exp(x)` / `exp2(x)` | e^x / 2^x |
+| `log(x)` / `log2(x)` | Natural / Base-2 logarithm |
+| `sqrt(x)` / `inversesqrt(x)` | Square root / 1/sqrt(x) |
+
+## Common Functions
+
+| Function | Description |
+|----------|-------------|
+| `abs(x)` / `sign(x)` | Absolute value / -1, 0, or 1 |
+| `floor(x)` / `ceil(x)` | Round down / up |
+| `fract(x)` | x - floor(x) |
+| `mod(x, y)` | x - y * floor(x/y) |
+| `min(x, y)` / `max(x, y)` | Minimum / Maximum |
+| `clamp(x, min, max)` | Constrain to range |
+| `mix(a, b, t)` | Linear interpolation: a*(1-t) + b*t |
+| `step(edge, x)` | 0.0 if x < edge, else 1.0 |
+| `smoothstep(e0, e1, x)` | Hermite interpolation |
+
+## Geometric Functions
+
+| Function | Description |
+|----------|-------------|
+| `length(v)` / `distance(a, b)` | Magnitude / Distance |
+| `dot(a, b)` / `cross(a, b)` | Dot / Cross product |
+| `normalize(v)` | Unit vector |
+| `reflect(i, n)` / `refract(i, n, eta)` | Reflection / Refraction |
+
+## Vector Relational Functions
+
+`lessThan`, `lessThanEqual`, `greaterThan`, `greaterThanEqual`, `equal`, `notEqual` - Return bvec.
+`any(bvec)`, `all(bvec)`, `not(bvec)` - Boolean operations.
+
+## Texture Functions
+
+| Function | Description |
+|----------|-------------|
+| `texture2D(sampler, coord)` | Sample 2D texture |
+| `textureCube(sampler, coord)` | Sample cube map |
+
+## Constants
+
+```glsl
+#define PI 3.14159265359
+#define TWO_PI 6.28318530718
+#define HALF_PI 1.57079632679
+```
+
+## Type Constructors
+
+```glsl
+vec2(x), vec2(x, y)
+vec3(x), vec3(xy, z), vec3(x, y, z)
+vec4(x), vec4(xyz, w), vec4(xy, zw)
+mat2(a, b, c, d), mat3(...), mat4(...)
+```
+
+## Operators
+
+```glsl
++  -  *  /           // Arithmetic (component-wise)
+<  >  <=  >=  ==  != // Comparison
+&&  ||  !            // Logical
+mat * mat            // Matrix multiply
+mat * vec            // Transform vector
+```
+
+## Qualifiers
+
+```glsl
+attribute  // Vertex input
+uniform    // Constant across draw
+varying    // Interpolated vertex->fragment
+lowp / mediump / highp  // Precision
+in / out / inout / const // Parameters
+```
+
+## Built-in Variables
+
+```glsl
+// Fragment Shader
+vec4 gl_FragCoord;   // Window coordinates
+vec4 gl_FragColor;   // Output color (write only)
+bool gl_FrontFacing; // Front face?
+vec2 gl_PointCoord;  // Point sprite [0,1]
+
+// Vertex Shader
+vec4 gl_Position;    // Clip-space position
+float gl_PointSize;  // Point size
+```

package/skills/shader/references/glsl-shapes-polygon-star-polar-sdf-combinations.md

@@ -0,0 +1,124 @@
+# Advanced Shapes & SDF Combinations
+
+Polygons, stars, polar shapes, and combining multiple SDFs.
+
+## Regular Polygon (N sides)
+
+```glsl
+float polygonSDF(vec2 st, vec2 center, float radius, int sides) {
+    st -= center;
+    float a = atan(st.y, st.x) + PI;
+    float r = TWO_PI / float(sides);
+    float d = cos(floor(0.5 + a / r) * r - a) * length(st);
+    return d - radius;
+}
+
+// Usage: hexagon
+float hex = polygonSDF(st, vec2(0.5), 0.3, 6);
+```
+
+## Star Shape
+
+```glsl
+float starSDF(vec2 st, vec2 center, float r1, float r2, int points) {
+    st -= center;
+    float a = atan(st.y, st.x);
+    float seg = TWO_PI / float(points);
+    a = mod(a, seg) - seg * 0.5;
+    float r = length(st);
+    float inner = r2 / cos(seg * 0.5);
+    float d = mix(r1, inner, step(0.0, a) * 2.0 - 1.0);
+    return r - d;
+}
+```
+
+## Polar Shapes
+
+```glsl
+// Convert to polar coordinates
+vec2 toPolar(vec2 st) {
+    vec2 pos = st - 0.5;
+    float r = length(pos) * 2.0;
+    float a = atan(pos.y, pos.x);
+    return vec2(r, a);
+}
+
+// Polar flower
+float flowerSDF(vec2 st, int petals, float amplitude) {
+    vec2 polar = toPolar(st);
+    float shape = 0.5 + amplitude * cos(float(petals) * polar.y);
+    return polar.x - shape;
+}
+
+// Gear shape
+float gearSDF(vec2 st, int teeth, float innerR, float outerR) {
+    vec2 polar = toPolar(st);
+    float tooth = step(0.5, fract(polar.y * float(teeth) / TWO_PI));
+    float radius = mix(innerR, outerR, tooth);
+    return polar.x - radius;
+}
+
+// Heart
+float heartSDF(vec2 st) {
+    st -= vec2(0.5, 0.4);
+    st.x *= 0.8;
+    float a = atan(st.x, st.y) / PI;
+    float r = length(st);
+    float h = abs(a);
+    float d = (13.0 * h - 22.0 * h * h + 10.0 * h * h * h) / (6.0 - 5.0 * h);
+    return r - d * 0.3;
+}
+```
+
+## Combining SDFs
+
+```glsl
+// Union (OR) - combine shapes
+float sdfUnion(float d1, float d2) {
+    return min(d1, d2);
+}
+
+// Intersection (AND) - overlap only
+float sdfIntersect(float d1, float d2) {
+    return max(d1, d2);
+}
+
+// Subtraction - cut out
+float sdfSubtract(float d1, float d2) {
+    return max(d1, -d2);
+}
+
+// XOR - either but not both
+float sdfXor(float d1, float d2) {
+    return max(min(d1, d2), -max(d1, d2));
+}
+```
+
+## Smooth Boolean Operations
+
+```glsl
+// Smooth union (blended edges)
+float sdfSmoothUnion(float d1, float d2, float k) {
+    float h = clamp(0.5 + 0.5 * (d2 - d1) / k, 0.0, 1.0);
+    return mix(d2, d1, h) - k * h * (1.0 - h);
+}
+
+// Smooth subtraction
+float sdfSmoothSubtract(float d1, float d2, float k) {
+    float h = clamp(0.5 - 0.5 * (d2 + d1) / k, 0.0, 1.0);
+    return mix(d1, -d2, h) + k * h * (1.0 - h);
+}
+
+// Smooth intersection
+float sdfSmoothIntersect(float d1, float d2, float k) {
+    float h = clamp(0.5 - 0.5 * (d2 - d1) / k, 0.0, 1.0);
+    return mix(d2, d1, h) + k * h * (1.0 - h);
+}
+```
+
+## SDF Modifications
+
+```glsl
+float ring(float d, float thickness) { return abs(d) - thickness; }
+float roundSDF(float d, float r) { return d - r; }
+```