fastnoiselite-builder 0.1.0 → 0.2.0

package/dist/tsl/transform/transform3d.tsl.d.ts

@@ -0,0 +1,6 @@
+import { TransformType3D } from '../../types';
+/**
+ * Returns a WGSL code snippet that transforms (x, y, z) variables in-place.
+ * Expects variables named x, y, z to exist as `var` in the calling scope.
+ */
+export declare function getTransformWGSL3D(type: TransformType3D): string;

package/dist/tsl/wgsl/constants.d.ts

@@ -0,0 +1,16 @@
+export declare function wgslPrimes(): string;
+export declare function wgslGradients2D(): string;
+export declare function wgslGradients3D(): string;
+export declare function wgslRandVecs2D(): string;
+export declare function wgslRandVecs3D(): string;
+export declare function wgslImul(): string;
+export declare function wgslHashR2(): string;
+export declare function wgslHashR3(): string;
+export declare function wgslValCoordR2(): string;
+export declare function wgslValCoordR3(): string;
+export declare function wgslGradCoordR2(): string;
+export declare function wgslGradCoordR3(): string;
+export declare function wgslInterpHermite(): string;
+export declare function wgslInterpQuintic(): string;
+export declare function wgslCubicLerp(): string;
+export declare function wgslPingPong(): string;

package/dist/tsl/wgsl/fractal/fbm.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Wraps a base 2D noise WGSL string with FBm fractal loop.
+ * Entry function: noise(x: f32, y: f32) -> f32
+ */
+export declare function wrapWithFBm2D(baseNoiseWGSL: string, baseNoiseFnName: string, seed: number, octaves: number, lacunarity: number, gain: number, weightedStrength: number, fractalBounding: number): string;
+/**
+ * Wraps a base 3D noise WGSL string with FBm fractal loop.
+ * Entry function: noise(x: f32, y: f32, z: f32) -> f32
+ */
+export declare function wrapWithFBm3D(baseNoiseWGSL: string, baseNoiseFnName: string, seed: number, octaves: number, lacunarity: number, gain: number, weightedStrength: number, fractalBounding: number): string;

package/dist/tsl/wgsl/fractal/index.d.ts

@@ -0,0 +1,3 @@
+export { wrapWithFBm2D, wrapWithFBm3D } from './fbm.wgsl';
+export { wrapWithRidged2D, wrapWithRidged3D } from './ridged.wgsl';
+export { wrapWithPingPong2D, wrapWithPingPong3D } from './pingpong.wgsl';

package/dist/tsl/wgsl/fractal/pingpong.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Wraps a base 2D noise WGSL string with PingPong fractal loop.
+ * Entry function: noise(x: f32, y: f32) -> f32
+ */
+export declare function wrapWithPingPong2D(baseNoiseWGSL: string, baseNoiseFnName: string, seed: number, octaves: number, lacunarity: number, gain: number, weightedStrength: number, fractalBounding: number, pingPongStrength: number): string;
+/**
+ * Wraps a base 3D noise WGSL string with PingPong fractal loop.
+ * Entry function: noise(x: f32, y: f32, z: f32) -> f32
+ */
+export declare function wrapWithPingPong3D(baseNoiseWGSL: string, baseNoiseFnName: string, seed: number, octaves: number, lacunarity: number, gain: number, weightedStrength: number, fractalBounding: number, pingPongStrength: number): string;

package/dist/tsl/wgsl/fractal/ridged.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Wraps a base 2D noise WGSL string with Ridged fractal loop.
+ * Entry function: noise(x: f32, y: f32) -> f32
+ */
+export declare function wrapWithRidged2D(baseNoiseWGSL: string, baseNoiseFnName: string, seed: number, octaves: number, lacunarity: number, gain: number, weightedStrength: number, fractalBounding: number): string;
+/**
+ * Wraps a base 3D noise WGSL string with Ridged fractal loop.
+ * Entry function: noise(x: f32, y: f32, z: f32) -> f32
+ */
+export declare function wrapWithRidged3D(baseNoiseWGSL: string, baseNoiseFnName: string, seed: number, octaves: number, lacunarity: number, gain: number, weightedStrength: number, fractalBounding: number): string;

package/dist/tsl/wgsl/helpers.d.ts

@@ -0,0 +1,6 @@
+export type WGSLHelper = 'primes' | 'primesDouble' | 'imul' | 'hashR2' | 'hashR3' | 'gradients2D' | 'gradients3D' | 'randVecs2D' | 'randVecs3D' | 'valCoordR2' | 'valCoordR3' | 'gradCoordR2' | 'gradCoordR3' | 'interpHermite' | 'interpQuintic' | 'cubicLerp' | 'pingPong';
+/**
+ * Emits all required WGSL helper declarations, deduplicated.
+ * Resolves dependencies automatically.
+ */
+export declare function emitWGSLHelpers(...helperLists: WGSLHelper[][]): string;

package/dist/tsl/wgsl/noise/cellular.wgsl.d.ts

@@ -0,0 +1,28 @@
+import { CellularDistanceFunction, CellularReturnType } from '../../../types';
+import type { WGSLHelper } from '../helpers';
+/**
+ * Returns WGSL string for Cellular 2D noise.
+ * Distance function and return type are baked at build-time.
+ * Entry function: cellular2d(seed: i32, x: f32, y: f32) -> f32
+ */
+export declare function getCellularNoiseWGSL2D(distFn: CellularDistanceFunction, returnType: CellularReturnType, jitterModifier: number): string;
+/**
+ * Returns WGSL string for Cellular 3D noise.
+ * Distance function and return type are baked at build-time.
+ * Entry function: cellular3d(seed: i32, x: f32, y: f32, z: f32) -> f32
+ */
+export declare function getCellularNoiseWGSL3D(distFn: CellularDistanceFunction, returnType: CellularReturnType, jitterModifier: number): string;
+export declare const CELLULAR_2D_HELPERS: WGSLHelper[];
+export declare const CELLULAR_3D_HELPERS: WGSLHelper[];
+/**
+ * Returns ONLY the core WGSL for Cellular 2D noise, without helper declarations.
+ * Includes: CELL_JITTER_2D constant, cellDist2d, cellReturn2d, cellular2d functions.
+ * Use with emitWGSLHelpers(CELLULAR_2D_HELPERS) to get the full shader.
+ */
+export declare function getCellularNoiseWGSL2DCore(distFn: CellularDistanceFunction, returnType: CellularReturnType, jitterModifier: number): string;
+/**
+ * Returns ONLY the core WGSL for Cellular 3D noise, without helper declarations.
+ * Includes: CELL_JITTER_3D constant, cellDist3d, cellReturn3d, cellular3d functions.
+ * Use with emitWGSLHelpers(CELLULAR_3D_HELPERS) to get the full shader.
+ */
+export declare function getCellularNoiseWGSL3DCore(distFn: CellularDistanceFunction, returnType: CellularReturnType, jitterModifier: number): string;

package/dist/tsl/wgsl/noise/index.d.ts

@@ -0,0 +1,6 @@
+export { getValueNoiseWGSL2D, getValueNoiseWGSL3D, getValueNoiseWGSL2DCore, getValueNoiseWGSL3DCore, VALUE_2D_HELPERS, VALUE_3D_HELPERS } from './value.wgsl';
+export { getPerlinNoiseWGSL2D, getPerlinNoiseWGSL3D, getPerlinNoiseWGSL2DCore, getPerlinNoiseWGSL3DCore, PERLIN_2D_HELPERS, PERLIN_3D_HELPERS } from './perlin.wgsl';
+export { getValueCubicNoiseWGSL2D, getValueCubicNoiseWGSL3D, getValueCubicNoiseWGSL2DCore, getValueCubicNoiseWGSL3DCore, VALUE_CUBIC_2D_HELPERS, VALUE_CUBIC_3D_HELPERS, } from './value-cubic.wgsl';
+export { getOpenSimplex2NoiseWGSL2D, getOpenSimplex2NoiseWGSL3D, getOpenSimplex2NoiseWGSL2DCore, getOpenSimplex2NoiseWGSL3DCore, OS2_NOISE_2D_HELPERS, OS2_NOISE_3D_HELPERS, } from './opensimplex2.wgsl';
+export { getOpenSimplex2SNoiseWGSL2D, getOpenSimplex2SNoiseWGSL3D, getOpenSimplex2SNoiseWGSL2DCore, getOpenSimplex2SNoiseWGSL3DCore, OS2S_NOISE_2D_HELPERS, OS2S_NOISE_3D_HELPERS, } from './opensimplex2s.wgsl';
+export { getCellularNoiseWGSL2D, getCellularNoiseWGSL3D, getCellularNoiseWGSL2DCore, getCellularNoiseWGSL3DCore, CELLULAR_2D_HELPERS, CELLULAR_3D_HELPERS, } from './cellular.wgsl';

package/dist/tsl/wgsl/noise/opensimplex2.wgsl.d.ts

@@ -0,0 +1,24 @@
+import type { WGSLHelper } from '../helpers';
+export declare const OS2_NOISE_2D_HELPERS: WGSLHelper[];
+export declare const OS2_NOISE_3D_HELPERS: WGSLHelper[];
+/**
+ * Returns WGSL string for OpenSimplex2 2D noise.
+ * Entry function: opensimplex2_2d(seed: i32, x: f32, y: f32) -> f32
+ */
+export declare function getOpenSimplex2NoiseWGSL2D(): string;
+/**
+ * Returns WGSL string for OpenSimplex2 3D noise.
+ * Entry function: opensimplex2_3d(seed_in: i32, x: f32, y: f32, z: f32) -> f32
+ * Uses real WGSL for loop (no hoisting issues unlike TSL Loop()).
+ */
+export declare function getOpenSimplex2NoiseWGSL3D(): string;
+/**
+ * Returns ONLY the core opensimplex2_2d function (no helper declarations).
+ * Use with emitWGSLHelpers(OS2_NOISE_2D_HELPERS) for deduplicated composition.
+ */
+export declare function getOpenSimplex2NoiseWGSL2DCore(): string;
+/**
+ * Returns ONLY the core opensimplex2_3d function (no helper declarations).
+ * Use with emitWGSLHelpers(OS2_NOISE_3D_HELPERS) for deduplicated composition.
+ */
+export declare function getOpenSimplex2NoiseWGSL3DCore(): string;

package/dist/tsl/wgsl/noise/opensimplex2s.wgsl.d.ts

@@ -0,0 +1,24 @@
+import type { WGSLHelper } from '../helpers';
+/**
+ * Returns WGSL string for OpenSimplex2S 2D noise.
+ * Entry function: opensimplex2s_2d(seed: i32, x: f32, y: f32) -> f32
+ */
+export declare function getOpenSimplex2SNoiseWGSL2D(): string;
+/**
+ * Returns WGSL string for OpenSimplex2S 3D noise.
+ * Entry function: opensimplex2s_3d(seed: i32, x: f32, y: f32, z: f32) -> f32
+ * Uses i32() for truncation toward zero (matches Math.trunc, NOT floor).
+ */
+export declare function getOpenSimplex2SNoiseWGSL3D(): string;
+export declare const OS2S_NOISE_2D_HELPERS: WGSLHelper[];
+export declare const OS2S_NOISE_3D_HELPERS: WGSLHelper[];
+/**
+ * Returns ONLY the `fn opensimplex2s_2d(...)` WGSL function body, without helper declarations.
+ * Use with emitWGSLHelpers(OS2S_NOISE_2D_HELPERS) to get the full shader.
+ */
+export declare function getOpenSimplex2SNoiseWGSL2DCore(): string;
+/**
+ * Returns ONLY the `fn opensimplex2s_3d(...)` WGSL function body, without helper declarations.
+ * Use with emitWGSLHelpers(OS2S_NOISE_3D_HELPERS) to get the full shader.
+ */
+export declare function getOpenSimplex2SNoiseWGSL3DCore(): string;

package/dist/tsl/wgsl/noise/perlin.wgsl.d.ts

@@ -0,0 +1,23 @@
+import type { WGSLHelper } from '../helpers';
+export declare const PERLIN_2D_HELPERS: WGSLHelper[];
+export declare const PERLIN_3D_HELPERS: WGSLHelper[];
+/**
+ * Returns WGSL string for Perlin 2D noise.
+ * Entry function: perlin2d(seed: i32, x: f32, y: f32) -> f32
+ */
+export declare function getPerlinNoiseWGSL2D(): string;
+/**
+ * Returns WGSL string for Perlin 3D noise.
+ * Entry function: perlin3d(seed: i32, x: f32, y: f32, z: f32) -> f32
+ */
+export declare function getPerlinNoiseWGSL3D(): string;
+/**
+ * Returns ONLY the core fn perlin2d WGSL (no helper declarations).
+ * Use with emitWGSLHelpers(PERLIN_2D_HELPERS) to get the full shader.
+ */
+export declare function getPerlinNoiseWGSL2DCore(): string;
+/**
+ * Returns ONLY the core fn perlin3d WGSL (no helper declarations).
+ * Use with emitWGSLHelpers(PERLIN_3D_HELPERS) to get the full shader.
+ */
+export declare function getPerlinNoiseWGSL3DCore(): string;

package/dist/tsl/wgsl/noise/value-cubic.wgsl.d.ts

@@ -0,0 +1,23 @@
+import type { WGSLHelper } from '../helpers';
+export declare const VALUE_CUBIC_2D_HELPERS: WGSLHelper[];
+export declare const VALUE_CUBIC_3D_HELPERS: WGSLHelper[];
+/**
+ * Returns WGSL string for ValueCubic 2D noise.
+ * Entry function: valuecubic2d(seed: i32, x: f32, y: f32) -> f32
+ */
+export declare function getValueCubicNoiseWGSL2D(): string;
+/**
+ * Returns WGSL string for ValueCubic 3D noise.
+ * Entry function: valuecubic3d(seed: i32, x: f32, y: f32, z: f32) -> f32
+ */
+export declare function getValueCubicNoiseWGSL3D(): string;
+/**
+ * Returns ONLY the core `fn valuecubic2d(...)` WGSL, without helper declarations.
+ * Helpers must be emitted separately via VALUE_CUBIC_2D_HELPERS.
+ */
+export declare function getValueCubicNoiseWGSL2DCore(): string;
+/**
+ * Returns ONLY the core `fn valuecubic3d(...)` WGSL, without helper declarations.
+ * Helpers must be emitted separately via VALUE_CUBIC_3D_HELPERS.
+ */
+export declare function getValueCubicNoiseWGSL3DCore(): string;

package/dist/tsl/wgsl/noise/value.wgsl.d.ts

@@ -0,0 +1,23 @@
+import type { WGSLHelper } from '../helpers';
+/**
+ * Returns WGSL string for Value 2D noise.
+ * Entry function: value2d(seed: i32, x: f32, y: f32) -> f32
+ */
+export declare function getValueNoiseWGSL2D(): string;
+/**
+ * Returns WGSL string for Value 3D noise.
+ * Entry function: value3d(seed: i32, x: f32, y: f32, z: f32) -> f32
+ */
+export declare function getValueNoiseWGSL3D(): string;
+export declare const VALUE_2D_HELPERS: WGSLHelper[];
+export declare const VALUE_3D_HELPERS: WGSLHelper[];
+/**
+ * Returns ONLY the `fn value2d(...)` WGSL function body, without helper declarations.
+ * Use with emitWGSLHelpers(VALUE_2D_HELPERS) to get the full shader.
+ */
+export declare function getValueNoiseWGSL2DCore(): string;
+/**
+ * Returns ONLY the `fn value3d(...)` WGSL function body, without helper declarations.
+ * Use with emitWGSLHelpers(VALUE_3D_HELPERS) to get the full shader.
+ */
+export declare function getValueNoiseWGSL3DCore(): string;

package/dist/tsl/wgsl/warp/basic-grid.wgsl.d.ts

@@ -0,0 +1,15 @@
+import type { WGSLHelper } from '../helpers';
+export declare const BASIC_GRID_WARP_2D_HELPERS: WGSLHelper[];
+export declare const BASIC_GRID_WARP_3D_HELPERS: WGSLHelper[];
+/**
+ * Returns WGSL core function for BasicGrid 2D domain warp.
+ * Entry: basicgrid_warp2d(seed: i32, x: f32, y: f32) -> vec2<f32>
+ * Returns unit displacement vector (caller applies amplitude).
+ */
+export declare function getBasicGridWarpWGSL2D(): string;
+/**
+ * Returns WGSL core function for BasicGrid 3D domain warp.
+ * Entry: basicgrid_warp3d(seed: i32, x: f32, y: f32, z: f32) -> vec3<f32>
+ * Returns unit displacement vector (caller applies amplitude).
+ */
+export declare function getBasicGridWarpWGSL3D(): string;

package/dist/tsl/wgsl/warp/index.d.ts

@@ -0,0 +1,2 @@
+export { getBasicGridWarpWGSL2D, getBasicGridWarpWGSL3D, BASIC_GRID_WARP_2D_HELPERS, BASIC_GRID_WARP_3D_HELPERS, } from './basic-grid.wgsl';
+export { getOpenSimplex2WarpWGSL2D, getOpenSimplex2WarpWGSL3D, OS2_WARP_2D_HELPERS_REDUCED, OS2_WARP_2D_HELPERS_FULL, OS2_WARP_3D_HELPERS_REDUCED, OS2_WARP_3D_HELPERS_FULL, } from './opensimplex2.wgsl';

package/dist/tsl/wgsl/warp/opensimplex2.wgsl.d.ts

@@ -0,0 +1,19 @@
+import type { WGSLHelper } from '../helpers';
+export declare const OS2_WARP_2D_HELPERS_REDUCED: WGSLHelper[];
+export declare const OS2_WARP_2D_HELPERS_FULL: WGSLHelper[];
+export declare const OS2_WARP_3D_HELPERS_REDUCED: WGSLHelper[];
+export declare const OS2_WARP_3D_HELPERS_FULL: WGSLHelper[];
+/**
+ * Returns WGSL core function for OpenSimplex2 2D domain warp.
+ * Entry: os2_warp2d(seed: i32, cx: f32, cy: f32) -> vec2<f32>
+ * cx, cy are the RAW input coords (F2 skew + frequency applied inside).
+ * Returns displacement vector.
+ */
+export declare function getOpenSimplex2WarpWGSL2D(frequency: number, reduced: boolean): string;
+/**
+ * Returns WGSL core function for OpenSimplex2 3D domain warp.
+ * Entry: os2_warp3d(seed_in: i32, x_in: f32, y_in: f32, z_in: f32) -> vec3<f32>
+ * x_in, y_in, z_in are already transformed + frequency-scaled.
+ * Returns displacement vector.
+ */
+export declare function getOpenSimplex2WarpWGSL3D(reduced: boolean): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastnoiselite-builder",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -9,9 +9,23 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./tsl": {
+      "import": "./dist/tsl/index.js",
+      "types": "./dist/tsl/index.d.ts"
     }
   },
-  "files": ["dist"],
+  "peerDependencies": {
+    "three": ">=0.170.0"
+  },
+  "peerDependenciesMeta": {
+    "three": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build:lib": "vite build --config vite.lib.config.js && tsc -p tsconfig.lib.json",
     "prepublishOnly": "npm run build:lib",
@@ -23,9 +37,10 @@
   },
   "devDependencies": {
     "@types/three": "^0.182.0",
+    "lil-gui": "^0.21.0",
     "three": "^0.182.0",
     "typescript": "~5.9.3",
     "vite": "^7.2.4",
     "vitest": "^4.0.18"
   }
-}
+}