@matboks/utilities 0.0.1

package/dist/math/fract.d.ts

@@ -0,0 +1 @@
+export declare function fract(value: number): number;

package/dist/math/fract.js

@@ -0,0 +1,3 @@
+export function fract(value) {
+    return value - Math.floor(value);
+}

package/dist/math/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./clamp.js";
+export * from "./fract.js";
+export * from "./mix.js";
+export * from "./mod.js";
+export * from "./signed.js";
+export * from "./smoothstep.js";
+export * from "./split-into-int-and-fract.js";
+export * from "./units.js";

package/dist/math/index.js

@@ -0,0 +1,8 @@
+export * from "./clamp.js";
+export * from "./fract.js";
+export * from "./mix.js";
+export * from "./mod.js";
+export * from "./signed.js";
+export * from "./smoothstep.js";
+export * from "./split-into-int-and-fract.js";
+export * from "./units.js";

package/dist/math/mix.d.ts

@@ -0,0 +1 @@
+export declare function mix(start: number, end: number, t: number): number;

package/dist/math/mix.js

@@ -0,0 +1,3 @@
+export function mix(start, end, t) {
+    return (1 - t) * start + t * end;
+}

package/dist/math/mod.d.ts

@@ -0,0 +1 @@
+export declare function mod(value: number, modulo: number): number;

package/dist/math/mod.js

@@ -0,0 +1,5 @@
+export function mod(value, modulo) {
+    if (!isFinite(modulo))
+        modulo = value + 1;
+    return ((value % modulo) + modulo) % modulo;
+}

package/dist/math/signed.d.ts

@@ -0,0 +1 @@
+export declare function signed(value: number): number;

package/dist/math/signed.js

@@ -0,0 +1,3 @@
+export function signed(value) {
+    return -1 + 2 * value;
+}

package/dist/math/smoothstep.d.ts

@@ -0,0 +1,3 @@
+export declare function smoothstep(value: number): number;
+export declare function smoothstep(value: number, lower: number, upper: number): number;
+export declare function smoothsteps(value: number, steps: number, flatness: number): number;

package/dist/math/smoothstep.js

@@ -0,0 +1,24 @@
+export function smoothstep(value, lower = 0, upper = 1) {
+    value = (value - lower) / (upper - lower);
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value * value * (3 - 2 * value);
+}
+export function smoothsteps(value, steps, flatness) {
+    if (value < 0)
+        return 0;
+    if (value >= 1)
+        return 1;
+    if (flatness === 1) {
+        return Math.floor(value * (steps + 1)) / steps;
+    }
+    else {
+        const l = (1 - flatness / (steps + 1)) / steps;
+        const v = value / l;
+        const vi = Math.floor(v);
+        const vf = v - vi;
+        return (vi + smoothstep(vf, flatness, 1)) / steps;
+    }
+}

package/dist/math/split-into-int-and-fract.d.ts

@@ -0,0 +1 @@
+export declare function splitIntoIntAndFract(value: number): number[];

package/dist/math/split-into-int-and-fract.js

@@ -0,0 +1,5 @@
+export function splitIntoIntAndFract(value) {
+    const vi = Math.floor(value);
+    const vf = value - vi;
+    return [vi, vf];
+}

package/dist/math/units.d.ts

@@ -0,0 +1,2 @@
+export declare function toDegrees(radians: number): number;
+export declare function toRadians(degrees: number): number;

package/dist/math/units.js

@@ -0,0 +1,6 @@
+export function toDegrees(radians) {
+    return radians * 180 / Math.PI;
+}
+export function toRadians(degrees) {
+    return degrees * Math.PI / 180;
+}

package/dist/noise/idw.d.ts

@@ -0,0 +1,11 @@
+import { AABB } from "../geometry/aabb.js";
+import { Vec2 } from "../geometry/vec2.js";
+import { RNG } from "../utilities/index.js";
+export type CreateIDWNoiseOptions = {
+    numPoints: number;
+    extent: AABB;
+    rng: RNG;
+    heightFunction: (position: Vec2, index: number) => number;
+    power?: number;
+};
+export declare function createIDWNoise(options: CreateIDWNoiseOptions): (v: Vec2, power?: number) => number;

package/dist/noise/idw.js

@@ -0,0 +1,10 @@
+import { createIDWInterpolator } from "../utilities/idw-interpolator.js";
+import { Poissonnier } from "../utilities/index.js";
+export function createIDWNoise(options) {
+    const { numPoints, extent, rng, heightFunction, power = 2 } = options;
+    const data = Poissonnier
+        .generateFixedSizeSample({ extent, sampleSize: numPoints, rng })
+        .sort((a, b) => a.y - b.y)
+        .map((position, i) => ({ position, value: heightFunction(position, i) }));
+    return createIDWInterpolator({ data, power });
+}

package/dist/noise/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./idw.js";
+export * from "./perlin.js";
+export * from "./random.js";
+export * from "./value.js";
+export * from "./worley.js";
+export * from "./voronoise.js";

package/dist/noise/index.js

@@ -0,0 +1,6 @@
+export * from "./idw.js";
+export * from "./perlin.js";
+export * from "./random.js";
+export * from "./value.js";
+export * from "./worley.js";
+export * from "./voronoise.js";

package/dist/noise/perlin.d.ts

@@ -0,0 +1,5 @@
+import { Vec2 } from "../geometry/vec2.js";
+import { Vec3 } from "../geometry/vec3.js";
+export declare function perlinNoise1D(p: number, scale: number, seed?: number): number;
+export declare function perlinNoise2D(p: Vec2, scale: number, seed?: number): number;
+export declare function perlinNoise3D(p: Vec3, scale: number, seed?: number): number;

package/dist/noise/perlin.js

@@ -0,0 +1,29 @@
+import { Vec2, vec2 } from "../geometry/vec2.js";
+import { vec3, Vec3 } from "../geometry/vec3.js";
+import { mix } from "../math/mix.js";
+import { signed } from "../math/signed.js";
+import { smoothstep } from "../math/smoothstep.js";
+import { random1D, randomUnit2D, randomUnit3D } from "./random.js";
+const NORMALIZE_1D = 2;
+const NORMALIZE_2D = Math.sqrt(2);
+const NORMALIZE_3D = Math.sqrt(4 / 3);
+export function perlinNoise1D(p, scale, seed = 0) {
+    p *= scale;
+    const pi = Math.floor(p);
+    const pf = p - pi;
+    const sf = smoothstep(pf);
+    const signedValue = mix(signed(random1D(pi, seed)) * pf, signed(random1D(pi + 1, seed)) * (pf - 1), sf);
+    return 0.5 + 0.5 * signedValue * NORMALIZE_1D;
+}
+export function perlinNoise2D(p, scale, seed = 0) {
+    const [pi, pf] = p.clone().times(scale).splitIntoIntAndFract();
+    const sf = Vec2.smoothstep(pf);
+    const signedValue = mix(mix(randomUnit2D(pi, seed).dot(pf), randomUnit2D(Vec2.add(pi, vec2(1, 0)), seed).dot(Vec2.subtract(pf, vec2(1, 0))), sf.x), mix(randomUnit2D(Vec2.add(pi, vec2(0, 1)), seed).dot(Vec2.subtract(pf, vec2(0, 1))), randomUnit2D(Vec2.add(pi, vec2(1, 1)), seed).dot(Vec2.subtract(pf, vec2(1, 1))), sf.x), sf.y);
+    return 0.5 + 0.5 * signedValue * NORMALIZE_2D;
+}
+export function perlinNoise3D(p, scale, seed = 0) {
+    const [pi, pf] = p.clone().times(scale).splitIntoIntAndFract();
+    const sf = Vec3.smoothstep(pf);
+    const signedValue = mix(mix(mix(randomUnit3D(pi, seed).dot(pf), randomUnit3D(Vec3.add(pi, vec3(1, 0, 0)), seed).dot(Vec3.subtract(pf, vec3(1, 0, 0))), sf.x), mix(randomUnit3D(Vec3.add(pi, vec3(0, 1, 0)), seed).dot(Vec3.subtract(pf, vec3(0, 1, 0))), randomUnit3D(Vec3.add(pi, vec3(1, 1, 0)), seed).dot(Vec3.subtract(pf, vec3(1, 1, 0))), sf.x), sf.y), mix(mix(randomUnit3D(Vec3.add(pi, vec3(0, 0, 1)), seed).dot(Vec3.subtract(pf, vec3(0, 0, 1))), randomUnit3D(Vec3.add(pi, vec3(1, 0, 1)), seed).dot(Vec3.subtract(pf, vec3(1, 0, 1))), sf.x), mix(randomUnit3D(Vec3.add(pi, vec3(0, 1, 1)), seed).dot(Vec3.subtract(pf, vec3(0, 1, 1))), randomUnit3D(Vec3.add(pi, vec3(1, 1, 1)), seed).dot(Vec3.subtract(pf, vec3(1, 1, 1))), sf.x), sf.y), sf.z);
+    return 0.5 + 0.5 * signedValue * NORMALIZE_3D;
+}

package/dist/noise/random.d.ts

@@ -0,0 +1,13 @@
+import { Vec2 } from "../geometry/vec2.js";
+import { Vec3 } from "../geometry/vec3.js";
+import { Vec4 } from "../geometry/vec4.js";
+export declare function random1D(p: number, seed?: number): number;
+export declare function random2D(p: Vec2, seed?: number): number;
+export declare function random3D(p: Vec3, seed?: number): number;
+export declare function random4D(p: Vec4, seed?: number): number;
+export declare function randomVec2(p: Vec2, seed?: number): Vec2;
+export declare function randomVec3(p: Vec3, seed?: number): Vec3;
+export declare function randomUnit2D(p: Vec2, seed?: number): Vec2;
+export declare function randomGaussian2D(p: Vec2, seed?: number): number;
+export declare function randomGaussian3D(p: Vec3, seed?: number): number;
+export declare function randomUnit3D(p: Vec3, seed?: number): Vec3;

package/dist/noise/random.js

@@ -0,0 +1,39 @@
+import { vec2, Vec2 } from "../geometry/vec2.js";
+import { vec3 } from "../geometry/vec3.js";
+import { vec4 } from "../geometry/vec4.js";
+import { hash } from "../utilities/rng.js";
+const NOISE_MULT = 1831565813.761235;
+export function random1D(p, seed = 0) {
+    return hash(NOISE_MULT * p, seed) / 4294967296;
+}
+export function random2D(p, seed = 0) {
+    return hash(NOISE_MULT * p.x ^ hash(NOISE_MULT * p.y, seed), seed) / 4294967296;
+}
+export function random3D(p, seed = 0) {
+    return hash(NOISE_MULT * p.x ^ hash(NOISE_MULT * p.y ^ hash(NOISE_MULT * p.z, seed), seed), seed) / 4294967296;
+}
+export function random4D(p, seed = 0) {
+    return hash(NOISE_MULT * p.x ^ hash(NOISE_MULT * p.y ^ hash(NOISE_MULT * p.z ^ hash(NOISE_MULT * p.w, seed), seed), seed), seed) / 4294967296;
+}
+export function randomVec2(p, seed = 0) {
+    return vec2(random3D(vec3(p.x, p.y, 1), seed), random3D(vec3(p.x, p.y, 2), seed));
+}
+export function randomVec3(p, seed = 0) {
+    return vec3(random4D(vec4(p, 1), seed), random4D(vec4(p, 2), seed), random4D(vec4(p, 3), seed));
+}
+export function randomUnit2D(p, seed = 0) {
+    return Vec2.fromPolar(1, 2 * Math.PI * random2D(p, seed));
+}
+export function randomGaussian2D(p, seed = 0) {
+    const u1 = random3D(p.toVec3(1), seed);
+    const u2 = random3D(p.toVec3(2), seed);
+    return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+export function randomGaussian3D(p, seed = 0) {
+    const u1 = random4D(vec4(p, 1), seed);
+    const u2 = random4D(vec4(p, 2), seed);
+    return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+export function randomUnit3D(p, seed = 0) {
+    return vec3(randomGaussian3D(p, seed), randomGaussian3D(p, hash(seed, 1)), randomGaussian3D(p, hash(seed, 2))).normalize();
+}

package/dist/noise/value.d.ts

@@ -0,0 +1,4 @@
+import { Vec2, Vec3 } from "../geometry/index.js";
+export declare function valueNoise1D(p: number, scale: number, seed?: number): number;
+export declare function valueNoise2D(p: Vec2, scale: number, seed?: number): number;
+export declare function valueNoise3D(p: Vec3, scale: number, seed?: number): number;

package/dist/noise/value.js

@@ -0,0 +1,20 @@
+import { vec2, Vec2, Vec3, vec3 } from "../geometry/index.js";
+import { smoothstep, mix } from "../math/index.js";
+import { random1D, random2D, random3D } from "./random.js";
+export function valueNoise1D(p, scale, seed = 0) {
+    p *= scale;
+    const pi = Math.floor(p);
+    const pf = p - pi;
+    const sf = smoothstep(pf);
+    return mix(random1D(pi, seed), random1D(pi + 1, seed), sf);
+}
+export function valueNoise2D(p, scale, seed = 0) {
+    const [pi, pf] = p.clone().times(scale).splitIntoIntAndFract();
+    const sf = Vec2.smoothstep(pf);
+    return mix(mix(random2D(pi, seed), random2D(Vec2.add(pi, vec2(1, 0)), seed), sf.x), mix(random2D(Vec2.add(pi, vec2(0, 1)), seed), random2D(Vec2.add(pi, vec2(1, 1)), seed), sf.x), sf.y);
+}
+export function valueNoise3D(p, scale, seed = 0) {
+    const [pi, pf] = p.clone().times(scale).splitIntoIntAndFract();
+    const sf = Vec3.smoothstep(pf);
+    return mix(mix(mix(random3D(pi, seed), random3D(Vec3.add(pi, vec3(1, 0, 0)), seed), sf.x), mix(random3D(Vec3.add(pi, vec3(0, 1, 0)), seed), random3D(Vec3.add(pi, vec3(1, 1, 0)), seed), sf.x), sf.y), mix(mix(random3D(Vec3.add(pi, vec3(0, 0, 1)), seed), random3D(Vec3.add(pi, vec3(1, 0, 1)), seed), sf.x), mix(random3D(Vec3.add(pi, vec3(0, 1, 1)), seed), random3D(Vec3.add(pi, vec3(1, 1, 1)), seed), sf.x), sf.y), sf.z);
+}

package/dist/noise/voronoise.d.ts

@@ -0,0 +1,10 @@
+import { Vec2 } from "../geometry/vec2.js";
+type VoronoiseOptions = {
+    p: Vec2;
+    scale: number;
+    disorder?: number;
+    smoothness?: number;
+    seed?: number;
+};
+export declare function voronoise2D(options: VoronoiseOptions): number | undefined;
+export {};

package/dist/noise/voronoise.js

@@ -0,0 +1,26 @@
+import { vec2, Vec2 } from "../geometry/vec2.js";
+import { smoothstep } from "../math/smoothstep.js";
+import { random2D, randomVec2 } from "./random.js";
+const { pow, sqrt } = Math;
+export function voronoise2D(options) {
+    const { p, scale, disorder = 1, smoothness = 1, seed } = options;
+    const [pi, pf] = p.clone().times(scale).splitIntoIntAndFract();
+    const power = 64.0 - 63.0 * pow(smoothness, 0.1);
+    let sum = 0;
+    let weightSum = 0;
+    const kernel = 2;
+    for (let row = -kernel; row <= kernel; row++) {
+        for (let column = -kernel; column <= kernel; column++) {
+            const index = vec2(column, row);
+            const corner = Vec2.add(pi, index);
+            const position = randomVec2(corner, seed).times(disorder);
+            const value = random2D(corner, seed);
+            const centerToPosition = Vec2.add(index, position).minus(pf);
+            const distSquared = centerToPosition.lengthSquared();
+            const weight = pow(smoothstep(sqrt(0.5 * distSquared), 1, 0), power);
+            sum += weight * value;
+            weightSum += weight;
+        }
+        return sum / weightSum;
+    }
+}

package/dist/noise/worley.d.ts

@@ -0,0 +1,4 @@
+import { Vec2, Vec3 } from "../geometry/index.js";
+export declare function worleyNoise1D(p: number, scale: number, seed?: number): number;
+export declare function worleyNoise2D(p: Vec2, scale: number, seed?: number): number;
+export declare function worleyNoise3D(p: Vec3, scale: number, seed?: number): number;

package/dist/noise/worley.js

@@ -0,0 +1,39 @@
+import { Vec2, vec2, vec3, Vec3 } from "../geometry/index.js";
+import { splitIntoIntAndFract } from "../math/split-into-int-and-fract.js";
+import { random1D, randomVec2, randomVec3 } from "./index.js";
+const { min, sqrt, abs } = Math;
+export function worleyNoise1D(p, scale, seed = 0) {
+    const [pi, pf] = splitIntoIntAndFract(scale * p);
+    let minDist = Infinity;
+    for (let index = -1; index <= 1; index++) {
+        const centerToPosition = index + random1D(pi + index, seed) - pf;
+        minDist = min(minDist, abs(centerToPosition));
+    }
+    return minDist;
+}
+export function worleyNoise2D(p, scale, seed = 0) {
+    const [pi, pf] = p.clone().times(scale).splitIntoIntAndFract();
+    let minDistSquared = Infinity;
+    for (let row = -1; row <= 1; row++) {
+        for (let column = -1; column <= 1; column++) {
+            const index = vec2(column, row);
+            const centerToPosition = index.plus(randomVec2(Vec2.add(pi, index), seed)).minus(pf);
+            minDistSquared = min(minDistSquared, centerToPosition.lengthSquared());
+        }
+    }
+    return sqrt(minDistSquared);
+}
+export function worleyNoise3D(p, scale, seed = 0) {
+    const [pi, pf] = p.clone().times(scale).splitIntoIntAndFract();
+    let minDistSquared = Infinity;
+    for (let row = -1; row <= 1; row++) {
+        for (let column = -1; column <= 1; column++) {
+            for (let slice = -1; slice <= 1; slice++) {
+                const index = vec3(column, row, slice);
+                const centerToPosition = index.plus(randomVec3(Vec3.add(pi, index), seed)).minus(pf);
+                minDistSquared = min(minDistSquared, centerToPosition.lengthSquared());
+            }
+        }
+    }
+    return sqrt(minDistSquared);
+}

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

@@ -0,0 +1,2 @@
+export * from "./registry.js";
+export * from "./library.js";

package/dist/shader-modules/index.js

@@ -0,0 +1,2 @@
+export * from "./registry.js";
+export * from "./library.js";

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

@@ -0,0 +1,2 @@
+import { GLSLLibrary } from "glsl-modules";
+export declare const glslkitLibrary: GLSLLibrary;

package/dist/shader-modules/library.js

@@ -0,0 +1,36 @@
+import { GLSLLibrary } from "glsl-modules";
+import { geometryDefinition } from "./modules/geometry.js";
+import { sdfDefinition } from "./modules/sdf/index.js";
+import { operationsDefinition } from "./modules/sdf/operations.js";
+import { arrowFunctionsPlugin, functionAsArgumentPlugin } from "glsl-modules/plugins";
+import { rayMarchingDefinition } from "./modules/ray-marching.js";
+import { cameraDefinition } from "./modules/camera.js";
+import { utilsDefinition } from "./modules/utils.js";
+import { constantsDefinition } from "./modules/constants.js";
+import { noiseDefinition } from "./modules/noise.js";
+import { randomDefinition } from "./modules/random.js";
+import { colorDefinition } from "./modules/color/index.js";
+import { blendDefinition } from "./modules/color/blend.js";
+import { mathDefinition } from "./modules/math.js";
+export const glslkitLibrary = new GLSLLibrary({
+    name: "glslkit",
+    definition: {
+        "color": {
+            "@index": colorDefinition,
+            "blend": blendDefinition
+        },
+        "geometry": geometryDefinition,
+        "math": mathDefinition,
+        "sdf": {
+            "@index": sdfDefinition,
+            "operations": operationsDefinition
+        },
+        "ray-marching": rayMarchingDefinition,
+        "camera": cameraDefinition,
+        "utils": utilsDefinition,
+        "constants": constantsDefinition,
+        "random": randomDefinition,
+        "noise": noiseDefinition,
+    },
+    plugins: [arrowFunctionsPlugin(), functionAsArgumentPlugin()]
+});

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

@@ -0,0 +1 @@
+export declare const cameraDefinition = "\n\nimport { create2DBasisVectors } from \"@/geometry\";\nimport { Ray } from \"@/ray-marching\";\nexport { \n  orthographicCamera,\n  perspectiveCamera\n}\n\nRay orthographicCamera(vec2 uv, vec3 cameraPosition, vec3 lookAt, float viewport, float aspectRatio, float rotation) {\n  vec3 normal = normalize(lookAt - cameraPosition);\n\n  mat2x3 basis = create2DBasisVectors(normal, rotation);\n\n  // The basis forms a RHS system, but uv coordinates from NDC are left-handed. \n  // To make rendered image as expected, the j vector is flipped\n  basis[1] = -basis[1];\n\n  vec2 offset = (uv - 0.5) * viewport * vec2(max(aspectRatio, 1.0), max(1.0 / aspectRatio, 1.0));\n\n  vec3 origin = cameraPosition + basis*offset;\n\n  return Ray(origin, normal);\n}\n\nRay perspectiveCamera(vec2 uv, vec3 cameraPosition, vec3 lookAt, float fov, float aspectRatio, float rotation) {\n  vec3 normal = normalize(lookAt - cameraPosition);\n\n  mat2x3 basis = create2DBasisVectors(normal, rotation);\n\n  // The basis forms a RHS system, but uv coordinates from NDC are left-handed. \n  // To make rendered image as expected, the j vector is flipped\n  basis[1] = -basis[1];\n\n\n  vec2 offset = 2.0 * (uv - 0.5) * tan(0.5*fov) * vec2(max(aspectRatio, 1.0), max(1.0 / aspectRatio, 1.0));\n\n  vec3 direction = normalize(normal + basis*offset);\n\n  return Ray(cameraPosition, direction);\n}\n\n";

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

@@ -0,0 +1,43 @@
+export const cameraDefinition = /*glsl*/ `
+
+import { create2DBasisVectors } from "@/geometry";
+import { Ray } from "@/ray-marching";
+export { 
+  orthographicCamera,
+  perspectiveCamera
+}
+
+Ray orthographicCamera(vec2 uv, vec3 cameraPosition, vec3 lookAt, float viewport, float aspectRatio, float rotation) {
+  vec3 normal = normalize(lookAt - cameraPosition);
+
+  mat2x3 basis = create2DBasisVectors(normal, rotation);
+
+  // The basis forms a RHS system, but uv coordinates from NDC are left-handed. 
+  // To make rendered image as expected, the j vector is flipped
+  basis[1] = -basis[1];
+
+  vec2 offset = (uv - 0.5) * viewport * vec2(max(aspectRatio, 1.0), max(1.0 / aspectRatio, 1.0));
+
+  vec3 origin = cameraPosition + basis*offset;
+
+  return Ray(origin, normal);
+}
+
+Ray perspectiveCamera(vec2 uv, vec3 cameraPosition, vec3 lookAt, float fov, float aspectRatio, float rotation) {
+  vec3 normal = normalize(lookAt - cameraPosition);
+
+  mat2x3 basis = create2DBasisVectors(normal, rotation);
+
+  // The basis forms a RHS system, but uv coordinates from NDC are left-handed. 
+  // To make rendered image as expected, the j vector is flipped
+  basis[1] = -basis[1];
+
+
+  vec2 offset = 2.0 * (uv - 0.5) * tan(0.5*fov) * vec2(max(aspectRatio, 1.0), max(1.0 / aspectRatio, 1.0));
+
+  vec3 direction = normalize(normal + basis*offset);
+
+  return Ray(cameraPosition, direction);
+}
+
+`;

package/dist/shader-modules/modules/color/blend.d.ts

@@ -0,0 +1 @@
+export declare const blendDefinition = "\n\nexport {\n  multiply, screen, overlay, hardLight, softLight, colorDodge, linearDodge, divide, colorBurn, linearBurn, vividLight, linearLight, subtract, difference, darken, lighten, blendById\n}\n\nvec3 multiply(vec3 a, vec3 b) {\n  return a*b;\n}\n\nvec3 screen(vec3 a, vec3 b) {\n  return 1.0 - (1.0 - a)*(1.0 - b);\n}\n\nvec3 overlay(vec3 a, vec3 b) {\n  return mix(2.0*a*b, 1.0 - 2.0*(1.0 - a)*(1.0 - b), step(0.5, a));\n}\n\nvec3 hardLight(vec3 a, vec3 b) {\n  return mix(2.0*a*b, 1.0 - 2.0*(1.0 - a)*(1.0 - b), step(0.5, b));\n}\n\nvec3 softLight(vec3 a, vec3 b) {\n  return (1.0 - 2.0*b)*a*a + 2.0*b*a;\n}\n\nvec3 colorDodge(vec3 a, vec3 b) {\n  return min(a / (1.0 - b), 1.0);\n}\n\nvec3 linearDodge(vec3 a, vec3 b) {\n  return min(a + b, 1.0);\n}\n\nvec3 divide(vec3 a, vec3 b) {\n  return min(a / b, 1.0);\n}\n\nvec3 colorBurn(vec3 a, vec3 b) {\n  return clamp(1.0 - (1.0 - a) / b, 0.0, 1.0);\n}\n\nvec3 linearBurn(vec3 a, vec3 b) {\n  return clamp(a + b - 1.0, 0.0, 1.0);\n}\n\nvec3 vividLight(vec3 a, vec3 b) {\n  return mix(colorBurn(a, b), colorDodge(a, b), step(0.5, b));\n}\n\nvec3 linearLight(vec3 a, vec3 b) {\n  return clamp(a + 2.0*b - 1.0, 0.0, 1.0);\n}\n\nvec3 subtract(vec3 a, vec3 b) {\n  return clamp(a - b, 0.0, 1.0);\n}\n\nvec3 difference(vec3 a, vec3 b) {\n  return abs(b - a);\n}\n\nvec3 darken(vec3 a, vec3 b) {\n  return min(a, b);\n}\n\nvec3 lighten(vec3 a, vec3 b) {\n  return max(a, b);\n}\n\nvec3 blendById(vec3 a, vec3 b, int id) {\n  id = max(0, min(id, 15));\n  if (id == 0) {\n    return multiply(a, b);\n  } else if (id == 1) {\n    return screen(a, b);\n  } else if (id == 2) {\n    return overlay(a, b);\n  } else if (id == 3) {\n    return hardLight(a, b);\n  } else if (id == 4) {\n    return softLight(a, b);\n  } else if (id == 5) {\n    return colorDodge(a, b);\n  } else if (id == 6) {\n    return linearDodge(a, b);\n  } else if (id == 7) {\n    return divide(a, b);\n  } else if (id == 8) {\n    return colorBurn(a, b);\n  } else if (id == 9) {\n    return linearBurn(a, b);\n  } else if (id == 10) {\n    return vividLight(a, b);\n  } else if (id == 11) {\n    return linearLight(a, b);\n  } else if (id == 12) {\n    return subtract(a, b);\n  } else if (id == 13) {\n    return difference(a, b);\n  } else if (id == 14) {\n    return darken(a, b);\n  } else if (id == 15) {\n    return lighten(a, b);\n  }\n}\n\n";

package/dist/shader-modules/modules/color/blend.js

@@ -0,0 +1,108 @@
+export const blendDefinition = /*glsl*/ `
+
+export {
+  multiply, screen, overlay, hardLight, softLight, colorDodge, linearDodge, divide, colorBurn, linearBurn, vividLight, linearLight, subtract, difference, darken, lighten, blendById
+}
+
+vec3 multiply(vec3 a, vec3 b) {
+  return a*b;
+}
+
+vec3 screen(vec3 a, vec3 b) {
+  return 1.0 - (1.0 - a)*(1.0 - b);
+}
+
+vec3 overlay(vec3 a, vec3 b) {
+  return mix(2.0*a*b, 1.0 - 2.0*(1.0 - a)*(1.0 - b), step(0.5, a));
+}
+
+vec3 hardLight(vec3 a, vec3 b) {
+  return mix(2.0*a*b, 1.0 - 2.0*(1.0 - a)*(1.0 - b), step(0.5, b));
+}
+
+vec3 softLight(vec3 a, vec3 b) {
+  return (1.0 - 2.0*b)*a*a + 2.0*b*a;
+}
+
+vec3 colorDodge(vec3 a, vec3 b) {
+  return min(a / (1.0 - b), 1.0);
+}
+
+vec3 linearDodge(vec3 a, vec3 b) {
+  return min(a + b, 1.0);
+}
+
+vec3 divide(vec3 a, vec3 b) {
+  return min(a / b, 1.0);
+}
+
+vec3 colorBurn(vec3 a, vec3 b) {
+  return clamp(1.0 - (1.0 - a) / b, 0.0, 1.0);
+}
+
+vec3 linearBurn(vec3 a, vec3 b) {
+  return clamp(a + b - 1.0, 0.0, 1.0);
+}
+
+vec3 vividLight(vec3 a, vec3 b) {
+  return mix(colorBurn(a, b), colorDodge(a, b), step(0.5, b));
+}
+
+vec3 linearLight(vec3 a, vec3 b) {
+  return clamp(a + 2.0*b - 1.0, 0.0, 1.0);
+}
+
+vec3 subtract(vec3 a, vec3 b) {
+  return clamp(a - b, 0.0, 1.0);
+}
+
+vec3 difference(vec3 a, vec3 b) {
+  return abs(b - a);
+}
+
+vec3 darken(vec3 a, vec3 b) {
+  return min(a, b);
+}
+
+vec3 lighten(vec3 a, vec3 b) {
+  return max(a, b);
+}
+
+vec3 blendById(vec3 a, vec3 b, int id) {
+  id = max(0, min(id, 15));
+  if (id == 0) {
+    return multiply(a, b);
+  } else if (id == 1) {
+    return screen(a, b);
+  } else if (id == 2) {
+    return overlay(a, b);
+  } else if (id == 3) {
+    return hardLight(a, b);
+  } else if (id == 4) {
+    return softLight(a, b);
+  } else if (id == 5) {
+    return colorDodge(a, b);
+  } else if (id == 6) {
+    return linearDodge(a, b);
+  } else if (id == 7) {
+    return divide(a, b);
+  } else if (id == 8) {
+    return colorBurn(a, b);
+  } else if (id == 9) {
+    return linearBurn(a, b);
+  } else if (id == 10) {
+    return vividLight(a, b);
+  } else if (id == 11) {
+    return linearLight(a, b);
+  } else if (id == 12) {
+    return subtract(a, b);
+  } else if (id == 13) {
+    return difference(a, b);
+  } else if (id == 14) {
+    return darken(a, b);
+  } else if (id == 15) {
+    return lighten(a, b);
+  }
+}
+
+`;

package/dist/shader-modules/modules/color/index.d.ts

@@ -0,0 +1 @@
+export declare const colorDefinition = "\n\nexport {\n  hslToRgb, rgbToHsl, shiftRgbInHsl,\n  hsvToRgb, rgbToHsv\n}\n\nvec3 hslToRgb(vec3 hsl) {\n  float h = mod(hsl.r, 360.0);\n  float s = clamp(hsl.g, 0.0, 1.0);\n  float l = clamp(hsl.b, 0.0, 1.0);\n\n  float c = s*(1.0 - abs(2.0*l - 1.0));\n  float x = c*(1.0 - abs(mod(h / 60.0, 2.0) - 1.0));\n  float m = l - c / 2.0;\n  \n  float r = 0.0;\n  float g = 0.0;\n  float b = 0.0;\n\n  if (h < 60.0) {\n    r = c;\n    g = x;\n  } else if (h < 120.0) {\n    r = x;\n    g = c;\n  } else if (h < 180.0) {\n    g = c;\n    b = x;\n  } else if (h < 240.0) {\n    g = x;\n    b = c;\n  } else if (h < 300.0) {\n    r = x;\n    b = c;\n  } else {\n    r = c;\n    b = x;\n  }\n  return vec3(r, g, b) + m;\n}\n\nvec3 hslToRgb(float h, float s, float l) {\n  return hslToRgb(vec3(h, s, l));\n}\n\nvec3 rgbToHsl(vec3 rgb) {\n  float r = rgb.r;\n  float g = rgb.g;\n  float b = rgb.b;\n\n  float cMax = max(r, max(g, b));\n  float cMin = min(r, min(g, b));\n  float delta = cMax - cMin;\n\n  float h;\n\n  if (delta == 0.0) {\n    h = 0.0;\n  } else if (r == cMax) {\n    h = mod((g - b)/delta, 6.0);\n  } else if (g == cMax) {\n    h = (b - r)/delta + 2.0;\n  } else if (b == cMax) {\n    h = (r - g)/delta + 4.0;\n  } \n  h *= 60.0;\n\th = mod(h, 360.0);\n\n  float l = (cMax + cMin)/2.0;\n\n  float s = 0.0;\n  if (delta > 0.0) {\n    s = delta/(1.0 - abs(2.0*l - 1.0));\n  }\n\n  return vec3(h, s, l);\n}\n\nvec3 rgbToHsl(float r, float g, float b) {\n  return rgbToHsl(vec3(r, g, b));\n}\n\nvec3 shiftRgbInHsl(vec3 rgb, vec3 shift) {\n  if (shift.z > 0.0) {\n    rgb = mix(rgb, vec3(1.0), shift.z);\n  } else {\n    rgb = mix(rgb, vec3(0.0), -shift.z);\n  }\n\n  vec3 hsl = rgbToHsl(rgb);\n\n  hsl.x += shift.x;\n\n  float sShift = shift.y;\n  if (sShift > 0.0) {\n    hsl.y = (1.0 - sShift)*hsl.y + sShift;\n  } else {\n    hsl.y = (1.0 + sShift)*hsl.y;\n  }\n\n  vec3 res = hslToRgb(hsl);\n\n  return res;\n}\n\nvec3 rgbToHsv(vec3 c)\n{\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),\n                 vec4(c.gb, K.xy),\n                 step(c.b, c.g));\n    vec4 q = mix(vec4(p.xyw, c.r),\n                 vec4(c.r, p.yzx),\n                 step(p.x, c.r));\n\n    float d = q.x - min(q.w, q.y);\n    float e = 1.0e-10;\n\n    return vec3(\n        abs(q.z + (q.w - q.y) / (6.0 * d + e)),\n        d / (q.x + e),                         \n        q.x                                    \n    );\n}\n\nvec3 hsv2Rgb(vec3 c)\n{\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\n    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n}\n\n";