@drawcall/charta 0.0.0

package/dist/water/texture.js

@@ -0,0 +1,201 @@
+import { DataTexture, RepeatWrapping, LinearMipMapLinearFilter, LinearFilter, RGBAFormat, RedFormat, UnsignedByteType, FloatType, Vector2, } from "three";
+import FFT from "fft.js";
+import seedrandom from "seedrandom";
+export function createWaveHeightTexture(options = {}) {
+    const size = options.size ?? 256;
+    const seed = options.seed ?? 1337;
+    const wind = options.windDirection
+        ? options.windDirection.clone().normalize()
+        : new Vector2(1, 1).normalize();
+    const windSpeed = options.windSpeed ?? 10.0;
+    const alignment = options.alignment ?? 1.0;
+    const heightScale = options.heightScale ?? 1.0;
+    const rng = seedrandom(seed.toString());
+    // 1. Generate frequency domain data using Phillips spectrum
+    // Phillips spectrum constants
+    const g = 9.81;
+    const L = (windSpeed * windSpeed) / g;
+    const L2 = L * L;
+    const numPixels = size * size;
+    const data = new Float32Array(numPixels * 2); // Complex data [re, im, re, im...]
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++) {
+            // Frequencies kx, kz
+            // Range -size/2 to size/2 corresponds to wavenumbers
+            let kx = x < size / 2 ? x : x - size;
+            let kz = y < size / 2 ? y : y - size;
+            // Scale to physical units (assuming patch size L_patch = size meters)
+            const patchSize = size;
+            kx = (2 * Math.PI * kx) / patchSize;
+            kz = (2 * Math.PI * kz) / patchSize;
+            const kLength = Math.sqrt(kx * kx + kz * kz);
+            if (kLength < 0.000001) {
+                data[(y * size + x) * 2] = 0;
+                data[(y * size + x) * 2 + 1] = 0;
+                continue;
+            }
+            const kDotW = (kx * wind.x + kz * wind.y) / kLength;
+            const k2 = kLength * kLength;
+            const k4 = k2 * k2;
+            // P(k) = A * exp(-1/(kL)^2) / k^4 * |k_hat dot w_hat|^2
+            // A is a global scale factor, we can fold it into heightScale or keep it 1.0
+            const A = 1000.0;
+            const suppression = Math.exp(-1 / (k2 * L2)) / k4;
+            const directional = Math.pow(Math.abs(kDotW), alignment * 2);
+            const Pk = A * suppression * directional;
+            // Generate random complex amplitude: h = (1/sqrt(2)) * (Gr + i*Gi) * sqrt(Pk)
+            // We use random Gaussian numbers for Gr, Gi
+            const hReal = gaussianRandom(rng) * Math.sqrt(Pk) * 0.707106;
+            const hImag = gaussianRandom(rng) * Math.sqrt(Pk) * 0.707106;
+            const idx = (y * size + x) * 2;
+            data[idx] = hReal;
+            data[idx + 1] = hImag;
+        }
+    }
+    // 2. Perform 2D Inverse FFT
+    const fft = new FFT(size);
+    const rowInput = new Float32Array(size * 2);
+    const rowOutput = new Float32Array(size * 2);
+    // Transposed output for column processing
+    const transposed = new Float32Array(numPixels * 2);
+    // Process Rows
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++) {
+            const idx = (y * size + x) * 2;
+            rowInput[x * 2] = data[idx];
+            rowInput[x * 2 + 1] = data[idx + 1];
+        }
+        fft.inverseTransform(rowOutput, rowInput);
+        // Write to transposed buffer immediately for next step
+        // Transposed: (x, y) -> (y, x)
+        // Input row y, col x -> Output row x, col y
+        for (let x = 0; x < size; x++) {
+            const outIdx = (x * size + y) * 2;
+            transposed[outIdx] = rowOutput[x * 2];
+            transposed[outIdx + 1] = rowOutput[x * 2 + 1];
+        }
+    }
+    // Process Columns (which are now rows in 'transposed')
+    // Reuse data array for final result
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++) {
+            const idx = (y * size + x) * 2;
+            rowInput[x * 2] = transposed[idx];
+            rowInput[x * 2 + 1] = transposed[idx + 1];
+        }
+        fft.inverseTransform(rowOutput, rowInput);
+        // Write back to 'data' or directly to heightData
+        // Note: This output is transposed relative to 'transposed', so it's back to (y, x) order
+        // But wait, we transposed once.
+        // If we process rows of the transposed matrix, we are processing columns of original.
+        // The output of this second pass is (y', x') where y' was x of original.
+        // So the result is transposed.
+        // Let's write to 'data' as (y, x) (where y corresponds to original col x, x to original row y)
+        for (let x = 0; x < size; x++) {
+            // We want to store it such that we can read it easily.
+            // Let's just store it in row-major order of the current iteration
+            const idx = (y * size + x) * 2;
+            data[idx] = rowOutput[x * 2];
+            data[idx + 1] = rowOutput[x * 2 + 1];
+        }
+    }
+    // Extract Real part (Height) and correct orientation
+    // 'data' now contains the 2D IFFT result, but it is Transposed because we did Row-Row pass where 2nd pass was on transposed data.
+    // Original: Rows -> Transpose -> Rows (Columns of orig) -> Result (Transposed)
+    // So data[y * size + x] corresponds to height at (x, y) of the original grid.
+    const heightData = new Float32Array(numPixels);
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++) {
+            // To get (y, x) of the final image, we read (x, y) from 'data'
+            // data index: x * size + y
+            const idx = (x * size + y) * 2;
+            const val = data[idx];
+            // Apply sign correction for FFT shift if needed? 
+            // Phillips spectrum usually doesn't require centering if k is handled correctly.
+            // However, standard FFT implementation might need normalization?
+            // fft.js usually doesn't normalize inverse transform by 1/N?
+            // Checking docs: "The inverse transform is unscaled."
+            // So we need to divide by size*size?
+            // Let's check if user provided 'heightScale' handles it.
+            // Usually we need to normalize.
+            // But let's just stick to the visual scaling for now or divide by size if it's huge.
+            // With size=256, val might be 65536 times larger.
+            // Let's normalize by numPixels to be safe mathematically, then apply heightScale.
+            // Update: fft.js inverseTransform already normalizes by 1/N.
+            // Since we do two passes (rows then cols), it normalizes by 1/N_rows * 1/N_cols = 1/numPixels.
+            // So 'val' is already normalized. dividing by numPixels again makes it tiny.
+            heightData[y * size + x] = val * heightScale;
+        }
+    }
+    const tex = new DataTexture(heightData, size, size, RedFormat, FloatType);
+    tex.wrapS = RepeatWrapping;
+    tex.wrapT = RepeatWrapping;
+    tex.minFilter = LinearMipMapLinearFilter;
+    tex.magFilter = LinearFilter;
+    tex.generateMipmaps = true;
+    tex.needsUpdate = true;
+    return tex;
+}
+export function createWaveNormalTexture(heightTexture, options = {}) {
+    const size = heightTexture.image.width;
+    const heightData = heightTexture.image.data;
+    // Generate Normal Map
+    const normalData = new Uint8Array(size * size * 4);
+    const strength = options.strength ?? 2.0; // Normal map strength
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++) {
+            const xp = (x - 1 + size) % size;
+            const xn = (x + 1) % size;
+            const yp = (y - 1 + size) % size;
+            const yn = (y + 1) % size;
+            const hx0 = heightData[y * size + xp];
+            const hx1 = heightData[y * size + xn];
+            const hy0 = heightData[yp * size + x];
+            const hy1 = heightData[yn * size + x];
+            // Central difference
+            // The texture is wrapped, so using neighbors is safe.
+            // The gradient here is dz/dx and dz/dy.
+            // If displacementScale in material is S, then actual height H = h * S.
+            // Gradient is (H(x+1)-H(x-1))/2 = (h(x+1)-h(x-1)) * S / 2.
+            // 'strength' here acts as the 'S / 2' factor relative to the '1 unit' pixel distance.
+            // If the user uses displacementScale=10, they probably want strong normals.
+            const dx = (hx1 - hx0) * strength;
+            const dy = (hy1 - hy0) * strength;
+            // Normal Vector construction
+            // Tangent Space:
+            // T = (1, 0, dx)
+            // B = (0, 1, dy)
+            // N = T x B = (-dx, -dy, 1)
+            // Normalized: n = N / |N|
+            // RGB Packing: 0.5 * n + 0.5
+            let nx = -dx;
+            let ny = -dy;
+            let nz = 1.0;
+            const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+            nx /= len;
+            ny /= len;
+            nz /= len;
+            const ptr = (y * size + x) * 4;
+            normalData[ptr] = ((nx * 0.5 + 0.5) * 255) | 0;
+            normalData[ptr + 1] = ((ny * 0.5 + 0.5) * 255) | 0;
+            normalData[ptr + 2] = ((nz * 0.5 + 0.5) * 255) | 0;
+            normalData[ptr + 3] = 255;
+        }
+    }
+    const tex = new DataTexture(normalData, size, size, RGBAFormat, UnsignedByteType);
+    tex.wrapS = RepeatWrapping;
+    tex.wrapT = RepeatWrapping;
+    tex.minFilter = LinearMipMapLinearFilter;
+    tex.magFilter = LinearFilter;
+    tex.generateMipmaps = true;
+    tex.needsUpdate = true;
+    return tex;
+}
+function gaussianRandom(rng) {
+    let u = 0, v = 0;
+    while (u === 0)
+        u = rng();
+    while (v === 0)
+        v = rng();
+    return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@drawcall/charta",
+  "version": "0.0.0",
+  "author": "Bela Bohlender",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://drawcall.ai",
+  "keywords": [
+    "drawcall.ai"
+  ],
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "type": "module",
+  "devDependencies": {
+    "@types/imurmurhash": "^0.1.4",
+    "@types/nearley": "^2.11.5",
+    "@types/seedrandom": "^3.0.8",
+    "moo": "^0.5.2",
+    "typescript": "^5.5.0",
+    "vitest": "^4.0.0"
+  },
+  "dependencies": {
+    "nearley": "^2.20.1",
+    "fft.js": "^4.0.4",
+    "imurmurhash": "^0.1.4",
+    "seedrandom": "^3.0.5",
+    "zod": "^4.1.12"
+  },
+  "peerDependencies": {
+    "three": ">=0.157.0"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build": "tsc -p tsconfig.json",
+    "generate": "nearleyc --module es src/grammar.ne -o src/grammar.ts && node -e \"const fs=require('fs'); const p='src/grammar.ts'; const s=fs.readFileSync(p,'utf8'); fs.writeFileSync(p, '// @ts-nocheck\\n'+s);\""
+  }
+}