@drawcall/charta 0.0.0

package/dist/walls/index.js

@@ -0,0 +1,376 @@
+import { Euler, Matrix4, Mesh, MeshBasicMaterial, Quaternion, Vector3, BufferAttribute, Texture, Shape, ExtrudeGeometry, Path, } from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { coerce, object, string, enum as enum_ } from 'zod';
+import { TilesGeometry } from '../tiles/geometry.js';
+import { buildTextureArrayFromAssets } from '../utils/texture.js';
+import { buildWallMeshMaterial } from './material.js';
+import { ChartaError } from '../errors.js';
+import { ceilingSchema, groundSchema } from '../tiles/index.js';
+const eulerHelper = new Euler();
+const scaleHelper = new Vector3(1, 1, 1);
+export const windowSchema = object({
+    offsetX: coerce.number().optional(),
+    bottomY: coerce.number().optional(),
+    topY: coerce.number().optional(),
+    width: coerce.number().optional(),
+});
+export const doorSchema = object({
+    offsetX: coerce.number().optional(),
+    bottomY: coerce.number().optional(),
+    topY: coerce.number().optional(),
+    height: coerce.number().optional(),
+    width: coerce.number().optional(),
+});
+export const wallSchema = object({
+    dir: enum_(['top', 'bottom', 'left', 'right']),
+    texture: string(),
+    bottomY: coerce.number().optional(),
+    topY: coerce.number().optional(),
+});
+export const WALL_CONFIG = {
+    top: { zOffset: -0.5, rotation: 0, axis: 'z', sampleDir: 1 },
+    bottom: { zOffset: 0.5, rotation: 0, axis: 'z', sampleDir: 1 },
+    left: {
+        xOffset: -0.5,
+        rotation: Math.PI / 2,
+        axis: 'x',
+        sampleDir: -1,
+    },
+    right: {
+        xOffset: 0.5,
+        rotation: Math.PI / 2,
+        axis: 'x',
+        sampleDir: -1,
+    },
+};
+export const WALL_CONNECTION_TOLERANCE_RATIO = 1 / 8;
+export function computeWallVerticalBounds(interpreter, tilesGeometry, row, col, wallIdx, parsed, config, loc) {
+    const rows = interpreter.getRows();
+    const cols = interpreter.getCols();
+    const cellSize = interpreter.getCellSize();
+    const snapThreshold = cellSize * WALL_CONNECTION_TOLERANCE_RATIO;
+    const isLayer = (c) => c.name === 'ground' || c.name === 'ceiling';
+    // Determine neighbor cell
+    let neighborRow = row;
+    let neighborCol = col;
+    if (parsed.dir === 'top')
+        neighborRow--;
+    else if (parsed.dir === 'bottom')
+        neighborRow++;
+    else if (parsed.dir === 'left')
+        neighborCol--;
+    else if (parsed.dir === 'right')
+        neighborCol++;
+    const [worldCellCenterX, worldCellCenterZ] = interpreter.getWorldCellCenter(row, col);
+    const localWallX = ('xOffset' in config ? config.xOffset : 0) * cellSize;
+    const localWallZ = ('zOffset' in config ? config.zOffset : 0) * cellSize;
+    const worldWallX = worldCellCenterX + localWallX;
+    const worldWallZ = worldCellCenterZ + localWallZ;
+    // Determine layer context
+    const layersBefore = interpreter.countCalls([row, col], isLayer, 0, wallIdx);
+    const layersAfter = interpreter.countCalls([row, col], isLayer, wallIdx + 1);
+    const resolveLayer = (explicitY, isTop) => {
+        // Case 1: No explicit height -> connect to adjacent layer in current cell
+        if (explicitY === undefined) {
+            if (isTop) {
+                if (layersAfter > 0)
+                    return { col, row, layerIdx: layersBefore }; // Index of immediate next layer
+                interpreter.reportError(new ChartaError(`wall at ${row}/${col}: missing topY and no subsequent layer`, interpreter.getSource(), loc));
+                return undefined;
+            }
+            else {
+                if (layersBefore > 0)
+                    return { col, row, layerIdx: layersBefore - 1 }; // Index of immediate prev layer
+                interpreter.reportError(new ChartaError(`wall at ${row}/${col}: missing bottomY and no preceding layer`, interpreter.getSource(), loc));
+                return undefined;
+            }
+        }
+        // Case 2: Explicit height -> check if close to any layer in current OR neighbor cell
+        let bestLayer;
+        let minDiff = Infinity;
+        const checkCell = (r, c) => {
+            if (r < 0 || r >= rows || c < 0 || c >= cols)
+                return;
+            const calls = interpreter.getCalls([r, c], { ground: groundSchema, ceiling: ceilingSchema });
+            for (let i = 0; i < calls.length; i++) {
+                const [, { y: layerY }] = calls[i];
+                const diff = Math.abs(layerY - explicitY);
+                if (diff < snapThreshold && diff < minDiff) {
+                    minDiff = diff;
+                    bestLayer = { col: c, row: r, layerIdx: i };
+                }
+            }
+        };
+        checkCell(row, col);
+        checkCell(neighborRow, neighborCol);
+        return bestLayer;
+    };
+    const bottomLayer = resolveLayer(parsed.bottomY, false);
+    const topLayer = resolveLayer(parsed.topY, true);
+    if (bottomLayer === undefined && parsed.bottomY === undefined)
+        return undefined;
+    if (topLayer === undefined && parsed.topY === undefined)
+        return undefined;
+    const sampleOffsets = [-cellSize / 2, 0, cellSize / 2];
+    const yStart = [0, 0, 0];
+    const yEnd = [0, 0, 0];
+    for (let k = 0; k < 3; k++) {
+        const off = sampleOffsets[k];
+        let sX = localWallX;
+        let sZ = localWallZ;
+        // Move along the wall direction
+        if (config.axis === 'z') {
+            sX += off * config.sampleDir;
+        }
+        else {
+            sZ += off * config.sampleDir;
+        }
+        // Sample Bottom
+        if (bottomLayer) {
+            const offX = sX + (col - bottomLayer.col) * cellSize;
+            const offZ = sZ + (row - bottomLayer.row) * cellSize;
+            yStart[k] = tilesGeometry.getHeight(bottomLayer.col, bottomLayer.row, bottomLayer.layerIdx, offX, offZ);
+        }
+        else {
+            yStart[k] = parsed.bottomY;
+        }
+        // Sample Top
+        if (topLayer) {
+            const offX = sX + (col - topLayer.col) * cellSize;
+            const offZ = sZ + (row - topLayer.row) * cellSize;
+            yEnd[k] = tilesGeometry.getHeight(topLayer.col, topLayer.row, topLayer.layerIdx, offX, offZ);
+        }
+        else {
+            yEnd[k] = parsed.topY;
+        }
+    }
+    // Ensure non-negative height (fix inverted walls)
+    for (let k = 0; k < 3; k++) {
+        if (yEnd[k] < yStart[k]) {
+            const tmp = yStart[k];
+            yStart[k] = yEnd[k];
+            yEnd[k] = tmp;
+        }
+    }
+    return {
+        yStart,
+        yEnd,
+        worldWallX,
+        worldWallZ,
+    };
+}
+export class WallMesh extends Mesh {
+    constructor(interpreter, material = new MeshBasicMaterial()) {
+        const rows = interpreter.getRows();
+        const cols = interpreter.getCols();
+        const cellSize = interpreter.getCellSize();
+        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry');
+        if (!tilesGeometry) {
+            super();
+            return;
+        }
+        const wallData = [];
+        const usedTextures = [];
+        const getWallTextureId = (texture) => {
+            let idx = usedTextures.indexOf(texture);
+            if (idx === -1) {
+                idx = usedTextures.length;
+                usedTextures.push(texture);
+            }
+            return idx;
+        };
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const entries = interpreter.getCalls([row, col], {
+                    wall: wallSchema,
+                    window: windowSchema,
+                    door: doorSchema,
+                });
+                let currentWall;
+                for (const [name, winOrDoor, wallIdx, loc] of entries) {
+                    if (name === 'window' || name === 'door') {
+                        if (!currentWall) {
+                            interpreter.reportError(new ChartaError(`${name} without preceding wall`, interpreter.getSource(), loc));
+                            continue;
+                        }
+                        const offsetX = winOrDoor.offsetX ?? 0;
+                        const width = winOrDoor.width ?? (name === 'door' ? 1.0 : Math.min(0.8, cellSize - 0.2));
+                        const halfWidth = currentWall.xzSize[0] / 2;
+                        const xMin = offsetX - width / 2;
+                        const xMax = offsetX + width / 2;
+                        // Check X bounds
+                        if (xMin < -halfWidth || xMax > halfWidth) {
+                            interpreter.reportError(new ChartaError(`${name} outside of wall width`, interpreter.getSource(), loc));
+                            continue;
+                        }
+                        // Helper to get wall Y at local x
+                        const getWallY = (localX, yTriple) => {
+                            const xNorm = (localX + halfWidth) / cellSize; // 0..1
+                            if (xNorm < 0.5) {
+                                // Interpolate between 0 (left) and 1 (center)
+                                const t = xNorm * 2;
+                                return yTriple[0] * (1 - t) + yTriple[1] * t;
+                            }
+                            else {
+                                // Interpolate between 1 (center) and 2 (right)
+                                const t = (xNorm - 0.5) * 2;
+                                return yTriple[1] * (1 - t) + yTriple[2] * t;
+                            }
+                        };
+                        // Check Y bounds at both ends of the window
+                        // We check at xMin and xMax
+                        const wallBottomLeft = getWallY(xMin, currentWall.yStart);
+                        const wallTopLeft = getWallY(xMin, currentWall.yEnd);
+                        const wallBottomRight = getWallY(xMax, currentWall.yStart);
+                        const wallTopRight = getWallY(xMax, currentWall.yEnd);
+                        const epsilon = 1e-3;
+                        const wallSafeBottom = Math.max(wallBottomLeft, wallBottomRight);
+                        const wallSafeTop = Math.min(wallTopLeft, wallTopRight);
+                        let bottomY;
+                        let topY;
+                        if (name === 'door') {
+                            bottomY = winOrDoor.bottomY ?? wallSafeBottom;
+                            topY = winOrDoor.topY ?? Math.min(wallSafeTop, bottomY + 2.0);
+                        }
+                        else {
+                            bottomY = winOrDoor.bottomY ?? Math.min(wallSafeTop, wallSafeBottom + 0.8);
+                            topY = winOrDoor.topY ?? Math.min(wallSafeTop, bottomY + 1.1);
+                        }
+                        if (bottomY < wallSafeBottom - epsilon ||
+                            topY > wallSafeTop + epsilon) {
+                            interpreter.reportError(new ChartaError(`${name} outside of wall height`, interpreter.getSource(), loc));
+                            continue;
+                        }
+                        currentWall.windows.push({
+                            offsetX,
+                            width,
+                            bottomY,
+                            topY,
+                        });
+                        continue;
+                    }
+                    const wallParsed = winOrDoor; // Type assertion since it could be wall or window in loop
+                    const config = WALL_CONFIG[wallParsed.dir];
+                    const bounds = computeWallVerticalBounds(interpreter, tilesGeometry, row, col, wallIdx, wallParsed, config, loc);
+                    if (!bounds) {
+                        currentWall = undefined;
+                        continue;
+                    }
+                    const texture = interpreter.getAsset(Texture, `${wallParsed.texture}BaseColorTexture`);
+                    if (!texture) {
+                        currentWall = undefined;
+                        continue;
+                    }
+                    const newWall = {
+                        x: bounds.worldWallX,
+                        z: bounds.worldWallZ,
+                        rotationY: config.rotation,
+                        xzSize: [cellSize, 0.1], // Walls are always cellSize width, 0.1 depth
+                        yStart: bounds.yStart,
+                        yEnd: bounds.yEnd,
+                        textureId: getWallTextureId(texture),
+                        windows: [],
+                    };
+                    wallData.push(newWall);
+                    currentWall = newWall;
+                }
+            }
+        }
+        // Build per-wall geometries (baked) and merge
+        const bakedGeometries = [];
+        const tmpMatrix = new Matrix4();
+        const tmpQuat = new Quaternion();
+        const tmpPos = new Vector3();
+        const fixWallUVs = (geom, width, depth) => {
+            const pos = geom.getAttribute('position');
+            const norm = geom.getAttribute('normal');
+            const uv = geom.getAttribute('uv');
+            for (let i = 0; i < pos.count; i++) {
+                const x = pos.getX(i);
+                const y = pos.getY(i);
+                const z = pos.getZ(i);
+                const nx = norm.getX(i);
+                const nz = norm.getZ(i);
+                if (Math.abs(nz) > 0.5) {
+                    // Front/Back
+                    uv.setXY(i, x + width / 2, y);
+                }
+                else if (Math.abs(nx) > 0.5) {
+                    // Side (Left/Right)
+                    uv.setXY(i, z + depth / 2, y);
+                }
+                else {
+                    // Top/Bottom
+                    uv.setXY(i, x + width / 2, z + depth / 2);
+                }
+            }
+            uv.needsUpdate = true;
+        };
+        for (const w of wallData) {
+            const width = w.xzSize[0];
+            const depth = w.xzSize[1];
+            const halfW = width / 2;
+            const shape = new Shape();
+            // Bottom edge (left to right)
+            shape.moveTo(-halfW, w.yStart[0]);
+            shape.lineTo(0, w.yStart[1]);
+            shape.lineTo(halfW, w.yStart[2]);
+            // Top edge (right to left)
+            shape.lineTo(halfW, w.yEnd[2]);
+            shape.lineTo(0, w.yEnd[1]);
+            shape.lineTo(-halfW, w.yEnd[0]);
+            shape.closePath();
+            for (const win of w.windows) {
+                const hole = new Path();
+                const wxMin = win.offsetX - win.width / 2;
+                const wxMax = win.offsetX + win.width / 2;
+                // Hole should have opposite winding order?
+                // Shape outer is CCW (default). Holes should be CW?
+                // Three.js Shape/Path usually handles this if using .holes.
+                // Let's define it:
+                hole.moveTo(wxMin, win.bottomY);
+                hole.lineTo(wxMax, win.bottomY);
+                hole.lineTo(wxMax, win.topY);
+                hole.lineTo(wxMin, win.topY);
+                hole.closePath();
+                shape.holes.push(hole);
+            }
+            const geom = new ExtrudeGeometry(shape, {
+                depth,
+                bevelEnabled: false,
+            });
+            // Center Z
+            geom.translate(0, 0, -depth / 2);
+            fixWallUVs(geom, width, depth);
+            // Assign per-vertex texture id
+            const vertexCount = geom.getAttribute('position').count;
+            const texIds = new Float32Array(vertexCount);
+            texIds.fill(w.textureId);
+            geom.setAttribute('textureId', new BufferAttribute(texIds, 1));
+            // Apply rotation and translation
+            tmpPos.set(w.x, 0, w.z);
+            tmpQuat.setFromEuler(eulerHelper.set(0, w.rotationY, 0));
+            tmpMatrix.compose(tmpPos, tmpQuat, scaleHelper);
+            geom.applyMatrix4(tmpMatrix);
+            bakedGeometries.push(geom);
+        }
+        let geometry;
+        if (bakedGeometries.length > 0) {
+            geometry = mergeGeometries(bakedGeometries, false);
+            geometry.computeVertexNormals();
+        }
+        super(geometry, material);
+        if (bakedGeometries.length === 0) {
+            this.visible = false;
+        }
+        if (usedTextures.length > 0) {
+            // Build texture array for wall materials and apply materials
+            const textureArray = buildTextureArrayFromAssets(usedTextures);
+            buildWallMeshMaterial(this.material, textureArray);
+        }
+    }
+}
+export function isLayerConnectedToWall(wallTopY, wallBotY, y, tileSize) {
+    const tolerance = tileSize * WALL_CONNECTION_TOLERANCE_RATIO;
+    return Math.abs(y - wallTopY) < tolerance || Math.abs(y - wallBotY) < tolerance;
+}

package/dist/walls/material.d.ts

@@ -0,0 +1,3 @@
+import { Material } from "three";
+export declare function buildWallMeshMaterial(material: Material, textureArray: any, normalTextureArray?: any): void;
+//# sourceMappingURL=material.d.ts.map

package/dist/walls/material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../src/walls/material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,GAAG,EACjB,kBAAkB,CAAC,EAAE,GAAG,GACvB,IAAI,CAgFN"}

package/dist/walls/material.js

@@ -0,0 +1,67 @@
+export function buildWallMeshMaterial(material, textureArray, normalTextureArray) {
+    if (normalTextureArray) {
+        material.defines = {
+            ...material.defines,
+            USE_NORMALMAP_TANGENTSPACE: "",
+            USE_TANGENT: "",
+        };
+    }
+    material.onBeforeCompile = (shader) => {
+        shader.uniforms.uTextureArray = { value: textureArray };
+        if (normalTextureArray) {
+            shader.uniforms.uNormalTextureArray = { value: normalTextureArray };
+        }
+        shader.vertexShader = shader.vertexShader.replace("#include <common>", `#include <common>
+      attribute float textureId;
+      varying float vTextureId;
+      varying vec2 vUv;`);
+        shader.vertexShader = shader.vertexShader.replace("#include <uv_vertex>", `
+      #include <uv_vertex>
+      vUv = uv;
+      vTextureId = textureId;
+      `);
+        shader.fragmentShader =
+            `
+      varying float vTextureId;
+      uniform sampler2DArray uTextureArray;
+      ${normalTextureArray ? "uniform sampler2DArray uNormalTextureArray;" : ""}
+      #ifndef USE_MAP
+        varying vec2 vUv;
+      #endif
+
+      vec2 hash2( vec2 p ) {
+        return fract(sin(vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3))))*43758.5453);
+      }
+
+      float voronoi( in vec2 x ) {
+        vec2 n = floor( x );
+        vec2 f = fract( x );
+        float m = 8.0;
+        for( int j=-1; j<=1; j++ )
+        for( int i=-1; i<=1; i++ ) {
+          vec2 g = vec2( float(i), float(j) );
+          vec2 o = hash2( n + g );
+          vec2 r = g - f + o;
+          float d = dot( r, r );
+          m = min( m, d );
+        }
+        return sqrt(m);
+      }
+    ` + shader.fragmentShader;
+        shader.fragmentShader = shader.fragmentShader.replace("#include <map_fragment>", `#include <map_fragment>
+      
+      float noise = voronoi(vUv * 0.6);
+      float mixVal = smoothstep(0.4, 0.6, noise);
+      
+      vec3 tex1 = texture(uTextureArray, vec3(vUv, vTextureId)).rgb;
+      vec3 tex2 = texture(uTextureArray, vec3(-vUv + 0.35, vTextureId)).rgb;
+      
+      vec3 texSample = mix(tex1, tex2, mixVal) * (voronoi(vUv * 0.5 + 12.0) * 0.2 + 0.9);
+      
+      diffuseColor.rgb *= texSample;`);
+        if (normalTextureArray) {
+            shader.fragmentShader = shader.fragmentShader.replace("#include <normal_fragment_maps>", `vec3 mapN = texture(uNormalTextureArray, vec3(vUv, vTextureId)).rgb * 2.0 - 1.0;
+        normal = normalize(tbn * mapN);`);
+        }
+    };
+}

package/dist/water/index.d.ts

@@ -0,0 +1,10 @@
+import { Mesh } from "three";
+import { Interpreter } from "../interpreter.js";
+export type WaterMeshOptions = {};
+export declare class WaterMesh extends Mesh {
+    constructor(interpreter: Interpreter, options?: WaterMeshOptions);
+    dispose(): void;
+}
+export * from "./texture.js";
+export * from "./material.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/water/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/water/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAIlC,qBAAa,SAAU,SAAQ,IAAI;gBACrB,WAAW,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB;IAsCpE,OAAO,IAAI,IAAI;CAMhB;AAED,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA"}

package/dist/water/index.js

@@ -0,0 +1,46 @@
+import { Mesh, Material } from "three";
+import { TilesGeometry } from "../tiles/geometry.js";
+import { coerce, object } from "zod";
+const waterSchema = object({ y: coerce.number() });
+export class WaterMesh extends Mesh {
+    constructor(interpreter, options = {}) {
+        const rows = interpreter.getRows();
+        const cols = interpreter.getCols();
+        // Build tiles[z][x] => Array<Tile>, containing only water tiles
+        const tiles = new Array(rows)
+            .fill(undefined)
+            .map(() => new Array(cols).fill(undefined).map(() => []));
+        for (let z = 0; z < rows; z++) {
+            for (let x = 0; x < cols; x++) {
+                const entries = interpreter.getCalls([z, x], { water: waterSchema });
+                const stack = [];
+                for (const [, parsed] of entries) {
+                    stack.push({
+                        type: "water",
+                        y: parsed.y,
+                        textureId: 0,
+                        cellIndexX: x,
+                        cellIndexZ: z,
+                    });
+                }
+                tiles[z][x] = stack;
+            }
+        }
+        const cellSize = interpreter.getCellSize();
+        const mapSizeX = cols * cellSize;
+        const mapSizeZ = rows * cellSize;
+        const geometry = new TilesGeometry(tiles, [], mapSizeX, mapSizeZ);
+        interpreter.setAsset("waterGeometry", geometry);
+        super(geometry);
+        this.renderOrder = 1;
+        this.frustumCulled = true;
+    }
+    dispose() {
+        this.geometry.dispose();
+        if (this.material instanceof Material) {
+            this.material.dispose();
+        }
+    }
+}
+export * from "./texture.js";
+export * from "./material.js";

package/dist/water/material.d.ts

@@ -0,0 +1,5 @@
+import { MeshStandardMaterial } from "three";
+export declare function createWaterMaterial(opts?: {
+    color?: number | string;
+}): MeshStandardMaterial;
+//# sourceMappingURL=material.d.ts.map

package/dist/water/material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../src/water/material.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EAIrB,MAAM,OAAO,CAAC;AAGf,wBAAgB,mBAAmB,CACjC,IAAI,GAAE;IACJ,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACpB,wBAoDP"}

package/dist/water/material.js

@@ -0,0 +1,46 @@
+import { MeshStandardMaterial, TangentSpaceNormalMap, Vector2, DoubleSide, } from "three";
+import { createWaveHeightTexture, createWaveNormalTexture } from "./texture.js";
+export function createWaterMaterial(opts = {}) {
+    // Water Effect Setup
+    const waveHeight = createWaveHeightTexture({
+        size: 512,
+        windSpeed: 8,
+        heightScale: 10.0, // Reduced scale because base wave height is now larger (physically correct)
+    });
+    // Create a separate normal map
+    const waveNormal = createWaveNormalTexture(waveHeight);
+    // Scale texture coordinates up to get more ripples per unit
+    waveHeight.repeat.setScalar(0.01);
+    waveNormal.repeat.setScalar(0.1);
+    const waterMat = new MeshStandardMaterial({
+        transparent: true,
+        color: opts.color ?? 0xccccff,
+        metalness: 0.3,
+        roughness: 0.1,
+        normalMap: waveNormal,
+        normalMapType: TangentSpaceNormalMap,
+        opacity: 0.5,
+        displacementScale: 0.1, // Use 1.0 for physically correct displacement
+        displacementMap: waveHeight,
+        normalScale: new Vector2().setScalar(0.5),
+        side: DoubleSide,
+    });
+    const waterFlow = { x: 0.005, y: 0.002 };
+    const normalFlow = { x: -0.005, y: 0.01 };
+    let waterTime = 0;
+    // Attach tick function to material
+    waterMat.tick = (delta) => {
+        waterTime += delta;
+        // Animate displacement map (height texture)
+        if (waterMat.displacementMap) {
+            waterMat.displacementMap.offset.x = (waterFlow.x * waterTime) % 1;
+            waterMat.displacementMap.offset.y = (waterFlow.y * waterTime) % 1;
+        }
+        // Animate normal map in a different direction for layered effect
+        if (waterMat.normalMap) {
+            waterMat.normalMap.offset.x = (normalFlow.x * waterTime) % 1;
+            waterMat.normalMap.offset.y = (normalFlow.y * waterTime) % 1;
+        }
+    };
+    return waterMat;
+}

package/dist/water/texture.d.ts

@@ -0,0 +1,15 @@
+import { DataTexture, Vector2 } from "three";
+export type WaveTextureOptions = {
+    size?: number;
+    seed?: number;
+    windDirection?: Vector2;
+    windSpeed?: number;
+    alignment?: number;
+    heightScale?: number;
+};
+export declare function createWaveHeightTexture(options?: WaveTextureOptions): DataTexture;
+export type WaveNormalOptions = {
+    strength?: number;
+};
+export declare function createWaveNormalTexture(heightTexture: DataTexture, options?: WaveNormalOptions): DataTexture;
+//# sourceMappingURL=texture.d.ts.map

package/dist/water/texture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture.d.ts","sourceRoot":"","sources":["../../src/water/texture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EAQX,OAAO,EACR,MAAM,OAAO,CAAC;AAIf,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,kBAAuB,GAC/B,WAAW,CA+Jb;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,WAAW,EAC1B,OAAO,GAAE,iBAAsB,GAC9B,WAAW,CAsEb"}