fastnoiselite-builder 0.1.0

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

@@ -0,0 +1,28 @@
+import type { NoiseFunction2D, NoiseFunction3D } from '../../types';
+import type { DistanceFunction2D, DistanceFunction3D } from './distance';
+import type { ReturnHandler } from './return-type';
+/**
+ * Creates a 2D cellular noise generator
+ *
+ * The distance function and return handler are "baked in" at build-time,
+ * eliminating runtime switches for maximum performance.
+ *
+ * @param seed - Random seed
+ * @param distanceFn - How to measure distance to cell points
+ * @param returnHandler - How to convert distances to noise value
+ * @param jitterModifier - Controls randomness of cell positions (0-1)
+ * @param useEuclideanSqrt - If true and using Euclidean, apply sqrt to distances
+ */
+export declare function createCellular2D(seed: number, distanceFn: DistanceFunction2D, returnHandler: ReturnHandler, jitterModifier?: number, useEuclideanSqrt?: boolean): NoiseFunction2D;
+/**
+ * Creates a 3D cellular noise generator
+ *
+ * Same principle as 2D but loops through a 3x3x3 grid
+ *
+ * @param seed - Random seed
+ * @param distanceFn - How to measure distance to cell points
+ * @param returnHandler - How to convert distances to noise value
+ * @param jitterModifier - Controls randomness of cell positions (0-1)
+ * @param useEuclideanSqrt - If true and using Euclidean, apply sqrt to distances
+ */
+export declare function createCellular3D(seed: number, distanceFn: DistanceFunction3D, returnHandler: ReturnHandler, jitterModifier?: number, useEuclideanSqrt?: boolean): NoiseFunction3D;

package/dist/noise/cellular/distance.d.ts

@@ -0,0 +1,43 @@
+import { CellularDistanceFunction } from '../../types';
+/**
+ * Distance function type for cellular noise
+ * Takes vector components and returns distance metric
+ */
+export type DistanceFunction2D = (vecX: number, vecY: number) => number;
+export type DistanceFunction3D = (vecX: number, vecY: number, vecZ: number) => number;
+/**
+ * Euclidean distance (squared) - no sqrt for performance
+ * Used for most cellular noise patterns
+ */
+export declare const euclideanSq2D: DistanceFunction2D;
+export declare const euclideanSq3D: DistanceFunction3D;
+/**
+ * Euclidean distance (squared)
+ * Returns distance² - the sqrt is applied by useEuclideanSqrt flag in cellular.ts
+ * This avoids double sqrt (which would give distance^(1/4) instead of distance)
+ */
+export declare const euclidean2D: DistanceFunction2D;
+export declare const euclidean3D: DistanceFunction3D;
+/**
+ * Manhattan distance - sum of absolute values
+ * Creates a diamond-shaped pattern
+ */
+export declare const manhattan2D: DistanceFunction2D;
+export declare const manhattan3D: DistanceFunction3D;
+/**
+ * Hybrid distance - combination of Manhattan and Euclidean
+ * Creates interesting mixed patterns
+ */
+export declare const hybrid2D: DistanceFunction2D;
+export declare const hybrid3D: DistanceFunction3D;
+/**
+ * Distance function names for configuration
+ */
+/**
+ * Get distance function by name for 2D
+ */
+export declare function getDistanceFunction2D(type: CellularDistanceFunction): DistanceFunction2D;
+/**
+ * Get distance function by name for 3D
+ */
+export declare function getDistanceFunction3D(type: CellularDistanceFunction): DistanceFunction3D;

package/dist/noise/cellular/index.d.ts

@@ -0,0 +1,3 @@
+export * from './distance';
+export * from './return-type';
+export * from './cellular';

package/dist/noise/cellular/return-type.d.ts

@@ -0,0 +1,48 @@
+import { CellularReturnType } from '../../types/enums';
+/**
+ * Return handler type for cellular noise
+ * Takes distances and hash, returns final noise value
+ * @param distance0 - Distance to closest cell point
+ * @param distance1 - Distance to second closest cell point
+ * @param closestHash - Hash value of closest cell
+ */
+export type ReturnHandler = (distance0: number, distance1: number, closestHash: number) => number;
+/**
+ * CellValue - Returns the value of the closest cell based on its hash
+ * Creates flat regions with hard edges between cells
+ */
+export declare const cellValue: ReturnHandler;
+/**
+ * Distance - Returns the distance to the closest cell point
+ * Creates a voronoi/worley pattern with gradient falloff
+ */
+export declare const distance: ReturnHandler;
+/**
+ * Distance2 - Returns the distance to the second closest cell point
+ * Creates larger cell-like patterns
+ */
+export declare const distance2: ReturnHandler;
+/**
+ * Distance2Add - Returns the average of both distances
+ * Creates smooth transitions between cells
+ */
+export declare const distance2Add: ReturnHandler;
+/**
+ * Distance2Sub - Returns the difference between distances
+ * Creates cellular boundaries/edges (useful for voronoi edges)
+ */
+export declare const distance2Sub: ReturnHandler;
+/**
+ * Distance2Mul - Returns the product of both distances
+ * Creates interesting organic patterns
+ */
+export declare const distance2Mul: ReturnHandler;
+/**
+ * Distance2Div - Returns the ratio of distances
+ * Creates sharp cellular patterns with varying sizes
+ */
+export declare const distance2Div: ReturnHandler;
+/**
+ * Get return handler by name
+ */
+export declare function getReturnHandler(type: CellularReturnType): ReturnHandler;

package/dist/noise/index.d.ts

@@ -0,0 +1,6 @@
+export * from './opensimplex2';
+export * from './opensimplex2s';
+export * from './perlin';
+export * from './value';
+export * from './value-cubic';
+export * from './cellular';

package/dist/noise/opensimplex2.d.ts

@@ -0,0 +1,9 @@
+import type { NoiseFunction2D, NoiseFunction3D } from '../types';
+/**
+ * Creates an OpenSimplex2 2D noise generator
+ */
+export declare function createOpenSimplex2_2D(seed: number): NoiseFunction2D;
+/**
+ * Creates an OpenSimplex2 3D noise generator
+ */
+export declare function createOpenSimplex2_3D(_seed: number): NoiseFunction3D;

package/dist/noise/opensimplex2s.d.ts

@@ -0,0 +1,9 @@
+import type { NoiseFunction2D, NoiseFunction3D } from '../types';
+/**
+ * Creates an OpenSimplex2S 2D noise generator (with skew)
+ */
+export declare function createOpenSimplex2S_2D(_seed: number): NoiseFunction2D;
+/**
+ * Creates an OpenSimplex2S 3D noise generator
+ */
+export declare function createOpenSimplex2S_3D(seed: number): NoiseFunction3D;

package/dist/noise/perlin.d.ts

@@ -0,0 +1,9 @@
+import type { NoiseFunction2D, NoiseFunction3D } from '../types';
+/**
+ * Creates a Perlin 2D noise generator
+ */
+export declare function createPerlin2D(seed: number): NoiseFunction2D;
+/**
+ * Creates a Perlin 3D noise generator
+ */
+export declare function createPerlin3D(seed: number): NoiseFunction3D;

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

@@ -0,0 +1,9 @@
+import type { NoiseFunction2D, NoiseFunction3D } from '../types';
+/**
+ * Creates a ValueCubic 2D noise generator
+ */
+export declare function createValueCubic2D(seed: number): NoiseFunction2D;
+/**
+ * Creates a ValueCubic 3D noise generator
+ */
+export declare function createValueCubic3D(seed: number): NoiseFunction3D;

package/dist/noise/value.d.ts

@@ -0,0 +1,9 @@
+import type { NoiseFunction2D, NoiseFunction3D } from '../types';
+/**
+ * Creates a Value 2D noise generator
+ */
+export declare function createValue2D(seed: number): NoiseFunction2D;
+/**
+ * Creates a Value 3D noise generator
+ */
+export declare function createValue3D(seed: number): NoiseFunction3D;

package/dist/transform/transform3dFunc.d.ts

@@ -0,0 +1,2 @@
+import { TransformType3D, type TransformFunction3D } from '../types';
+export declare function createTransform3DFunc(type: TransformType3D): TransformFunction3D;

package/dist/types/common.d.ts

@@ -0,0 +1,56 @@
+export interface Vector2 {
+    x: number;
+    y: number;
+}
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * A 2D noise function that takes x, y coordinates and returns a noise value [-1, 1]
+ */
+export type NoiseFunction2D = (x: number, y: number) => number;
+/**
+ * A 3D noise function that takes x, y, z coordinates and returns a noise value [-1, 1]
+ */
+export type NoiseFunction3D = (x: number, y: number, z: number) => number;
+/**
+ * A 3D transform function that modifies coordinates
+ */
+export type TransformFunction3D = (x: number, y: number, z: number) => {
+    x: number;
+    y: number;
+    z: number;
+};
+/**
+ * A 2D domain warp function that modifies coordinates
+ */
+export type WarpFunction2D = (x: number, y: number, coord: Vector2) => void;
+/**
+ * A 3D domain warp function that modifies coordinates
+ */
+export type WarpFunction3D = (x: number, y: number, z: number, coord: Vector3) => void;
+/**
+ * Context for noise generation
+ */
+export interface NoiseContext {
+    seed: number;
+    frequency: number;
+}
+/**
+ * Context for fractal noise generation
+ */
+export interface FractalContext extends NoiseContext {
+    octaves: number;
+    lacunarity: number;
+    gain: number;
+    weightedStrength: number;
+    fractalBounding: number;
+}
+/**
+ * Context for ping-pong fractal
+ */
+export interface PingPongContext extends FractalContext {
+    pingPongStrength: number;
+}

package/dist/types/config.d.ts

@@ -0,0 +1,28 @@
+import { FractalType, CellularDistanceFunction, CellularReturnType, DomainWarpType, DomainWarpFractalType, TransformType3D, NoiseType } from './enums';
+/**
+ * Configuration for noise generation
+ */
+export interface NoiseConfig {
+    seed: number;
+    frequency: number;
+    noiseType: NoiseType;
+    fractalType: FractalType;
+    fractalOctaves: number;
+    fractalLacunarity: number;
+    fractalGain: number;
+    fractalWeightedStrength: number;
+    fractalPingPongStrength: number;
+    cellularDistanceFunction: CellularDistanceFunction;
+    cellularReturnType: CellularReturnType;
+    cellularJitter: number;
+    rotationType3D: TransformType3D;
+    warpTransformType3D: TransformType3D;
+    transformType3D: TransformType3D;
+    domainWarpType: DomainWarpType;
+    domainWarpAmplitude: number;
+    domainWarpFrequency: number;
+    domainWarpFractalType: DomainWarpFractalType;
+    domainWarpFractalOctaves: number;
+    domainWarpFractalLacunarity: number;
+    domainWarpFractalGain: number;
+}

package/dist/types/enums.d.ts

@@ -0,0 +1,67 @@
+declare const NoiseType: {
+    readonly OpenSimplex2: "OpenSimplex2";
+    readonly OpenSimplex2S: "OpenSimplex2S";
+    readonly Perlin: "Perlin";
+    readonly Value: "Value";
+    readonly ValueCubic: "ValueCubic";
+    readonly Cellular: "Cellular";
+};
+type NoiseType = (typeof NoiseType)[keyof typeof NoiseType];
+export { NoiseType };
+declare const RotationType3D: {
+    readonly None: "None";
+    readonly ImproveXYPlanes: "ImproveXYPlanes";
+    readonly ImproveXZPlanes: "ImproveXZPlanes";
+};
+type RotationType3D = (typeof RotationType3D)[keyof typeof RotationType3D];
+export { RotationType3D };
+declare const FractalType: {
+    readonly None: "None";
+    readonly FBm: "FBm";
+    readonly Ridged: "Ridged";
+    readonly PingPong: "PingPong";
+};
+type FractalType = (typeof FractalType)[keyof typeof FractalType];
+export { FractalType };
+declare const CellularDistanceFunction: {
+    readonly Euclidean: "Euclidean";
+    readonly EuclideanSq: "EuclideanSq";
+    readonly Manhattan: "Manhattan";
+    readonly Hybrid: "Hybrid";
+};
+type CellularDistanceFunction = (typeof CellularDistanceFunction)[keyof typeof CellularDistanceFunction];
+export { CellularDistanceFunction };
+declare const CellularReturnType: {
+    readonly CellValue: "CellValue";
+    readonly Distance: "Distance";
+    readonly Distance2: "Distance2";
+    readonly Distance2Add: "Distance2Add";
+    readonly Distance2Sub: "Distance2Sub";
+    readonly Distance2Mul: "Distance2Mul";
+    readonly Distance2Div: "Distance2Div";
+};
+type CellularReturnType = (typeof CellularReturnType)[keyof typeof CellularReturnType];
+export { CellularReturnType };
+declare const DomainWarpType: {
+    readonly None: "None";
+    readonly OpenSimplex2: "OpenSimplex2";
+    readonly OpenSimplex2Reduced: "OpenSimplex2Reduced";
+    readonly BasicGrid: "BasicGrid";
+};
+type DomainWarpType = (typeof DomainWarpType)[keyof typeof DomainWarpType];
+export { DomainWarpType };
+declare const DomainWarpFractalType: {
+    readonly None: "None";
+    readonly Progressive: "Progressive";
+    readonly Independent: "Independent";
+};
+type DomainWarpFractalType = (typeof DomainWarpFractalType)[keyof typeof DomainWarpFractalType];
+export { DomainWarpFractalType };
+declare const TransformType3D: {
+    readonly None: "None";
+    readonly ImproveXYPlanes: "ImproveXYPlanes";
+    readonly ImproveXZPlanes: "ImproveXZPlanes";
+    readonly DefaultOpenSimplex2: "DefaultOpenSimplex2";
+};
+type TransformType3D = (typeof TransformType3D)[keyof typeof TransformType3D];
+export { TransformType3D };

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './config';
+export * from './enums';

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

@@ -0,0 +1,23 @@
+import type { WarpFunction2D, WarpFunction3D } from './types';
+/**
+ * Creates a 2D basic grid domain warp function
+ *
+ * BasicGrid warp uses a grid-based approach with hermite interpolation
+ * to create smooth deformations of the coordinate space.
+ *
+ * @param seed - Random seed
+ * @param warpAmp - Amplitude of the warp effect
+ * @param frequency - Frequency of the warp pattern
+ */
+export declare function createBasicGridWarp2D(seed: number, warpAmp: number, frequency: number): WarpFunction2D;
+/**
+ * Creates a 3D basic grid domain warp function
+ *
+ * 3D version extends the 2D grid-based approach with trilinear interpolation
+ * to create smooth 3D coordinate space deformations.
+ *
+ * @param seed - Random seed
+ * @param warpAmp - Amplitude of the warp effect
+ * @param frequency - Frequency of the warp pattern
+ */
+export declare function createBasicGridWarp3D(seed: number, warpAmp: number, frequency: number): WarpFunction3D;

package/dist/warp/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './basic-grid';
+export * from './opensimplex2';

package/dist/warp/opensimplex2.d.ts

@@ -0,0 +1,25 @@
+import type { WarpFunction2D, WarpFunction3D } from './types';
+/**
+ * Creates a 2D OpenSimplex2 domain warp function
+ *
+ * Uses the OpenSimplex2 algorithm to generate gradient vectors that warp
+ * the coordinate space. More organic and flowing than BasicGrid warp.
+ *
+ * @param seed - Random seed
+ * @param warpAmp - Amplitude of the warp effect
+ * @param frequency - Frequency of the warp pattern
+ * @param reduced - If true, uses simplified "reduced" mode (gradOnly)
+ */
+export declare function createOpenSimplex2Warp2D(seed: number, warpAmp: number, frequency: number, reduced?: boolean): WarpFunction2D;
+/**
+ * Creates a 3D OpenSimplex2 domain warp function
+ *
+ * 3D version of OpenSimplex2 warp using the same algorithm as 3D OpenSimplex2 noise
+ * but accumulating gradient vectors instead of noise values.
+ *
+ * @param _seed - Random seed
+ * @param warpAmp - Amplitude of the warp effect
+ * @param frequency - Frequency of the warp pattern
+ * @param reduced - If true, uses simplified "reduced" mode (gradOnly)
+ */
+export declare function createOpenSimplex2Warp3D(_seed: number, warpAmp: number, frequency: number, reduced?: boolean): WarpFunction3D;

package/dist/warp/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Mutable 2D coordinates for domain warping
+ * Domain warp modifies coordinates in-place
+ */
+export interface WarpCoord2D {
+    x: number;
+    y: number;
+}
+/**
+ * Mutable 3D coordinates for domain warping
+ * Domain warp modifies coordinates in-place
+ */
+export interface WarpCoord3D {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Domain warp function type for 2D
+ * Takes coordinates and modifies them in-place
+ */
+export type WarpFunction2D = (coord: WarpCoord2D) => void;
+/**
+ * Domain warp function type for 3D
+ * Takes coordinates and modifies them in-place
+ */
+export type WarpFunction3D = (coord: WarpCoord3D, x: number, y: number, z: number) => void;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "fastnoiselite-builder",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build:lib": "vite build --config vite.lib.config.js && tsc -p tsconfig.lib.json",
+    "prepublishOnly": "npm run build:lib",
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "test": "vitest",
+    "test:ui": "vitest --ui"
+  },
+  "devDependencies": {
+    "@types/three": "^0.182.0",
+    "three": "^0.182.0",
+    "typescript": "~5.9.3",
+    "vite": "^7.2.4",
+    "vitest": "^4.0.18"
+  }
+}