@drawcall/charta 0.0.0

package/dist/tiles/geometry.js

@@ -0,0 +1,463 @@
+import { BufferGeometry, Float32BufferAttribute, Uint16BufferAttribute, } from 'three';
+import { isLayerConnectedToWall } from '../walls/index.js';
+const MAX_AUTO_CONNECT_HEIGHT_DIFF_RATIO = 1 / 4;
+const MAX_CONNECTION_HEIGHT_DIFF_RATIO = 8;
+function isBetterConnection(newConnection, oldConnection, tileSize) {
+    const getDistance = (c) => Math.abs(c[0].y - c[1].y);
+    const distNew = Math.max(tileSize, getDistance(newConnection));
+    const distOld = Math.max(tileSize, getDistance(oldConnection));
+    if (distNew !== distOld)
+        return distNew < distOld;
+    const sameTypeNew = newConnection[0].type === newConnection[1].type;
+    const sameTypeOld = oldConnection[0].type === oldConnection[1].type;
+    if (sameTypeNew !== sameTypeOld)
+        return sameTypeNew;
+    return getDistance(newConnection) < getDistance(oldConnection);
+}
+function isBlockedByWall(t1, t2, walls, tileSize) {
+    const closestWall1 = getClosestConnectedWall(t1, walls, tileSize);
+    const closestWall2 = getClosestConnectedWall(t2, walls, tileSize);
+    if (closestWall1 != null && closestWall2 != null) {
+        //both not null
+        if (closestWall1 != closestWall2) {
+            //if not connected to the same wall -> blocked
+            return true;
+        }
+        //block if not connected to the same part
+        return getClosestWallPart(closestWall1, t1) != getClosestWallPart(closestWall2, t2);
+    }
+    if (closestWall1 === closestWall2) {
+        //both null -> not blocked
+        return false;
+    }
+    //exactly one is null
+    const closestWall = closestWall1 ?? closestWall2;
+    //check if for the wall either t1 or t2 is connected to that the other tile is also rather connected to that part
+    if (getClosestWallPart(closestWall, t1) != getClosestWallPart(closestWall, t2)) {
+        return true;
+    }
+    //we differentiate between top and bottom connected walls since top connected walls tend to be human-made and therefore we block based on the texture id
+    if (getClosestWallPart(closestWall, t1) === 'bottomY') {
+        return false;
+    }
+    if (t1.textureId != t2.textureId) {
+        return true;
+    }
+    return false;
+}
+function getClosestConnectedWall(tile, walls, tileSize) {
+    let distance = Infinity;
+    let result;
+    for (const wall of walls) {
+        if (!isLayerConnectedToWall(wall.topY, wall.bottomY, tile.y, tileSize)) {
+            continue;
+        }
+        let newDistance = Math.min(Math.abs(tile.y - wall.topY), Math.abs(tile.y - wall.bottomY));
+        if (newDistance < distance) {
+            result = wall;
+            distance = newDistance;
+        }
+    }
+    return result;
+}
+function getClosestWallPart(wall, tile) {
+    return Math.abs(wall.bottomY - tile.y) < Math.abs(wall.topY - tile.y) ? 'bottomY' : 'topY';
+}
+function isBlockingWall(wall, tile, tileSize) {
+    return isLayerConnectedToWall(wall.topY, wall.bottomY, tile.y, tileSize);
+}
+function getRelevantWallIndices(tile, vertexX, vertexZ, cellSizeX, cellSizeZ) {
+    const centerX = computeMeter('x', tile.cellIndexX, cellSizeX);
+    const centerZ = computeMeter('z', tile.cellIndexZ, cellSizeZ);
+    const dx = vertexX - centerX;
+    const dz = vertexZ - centerZ;
+    const eps = 1e-3;
+    const indices = [];
+    if (dz < -cellSizeZ * 0.25 + eps)
+        indices.push(0); // Top
+    if (dx > cellSizeX * 0.25 - eps)
+        indices.push(1); // Right
+    if (dz > cellSizeZ * 0.25 - eps)
+        indices.push(2); // Bottom
+    if (dx < -cellSizeX * 0.25 + eps)
+        indices.push(3); // Left
+    return indices;
+}
+function computeConnections(cell1, cell2, walls, tileSize) {
+    const connectedTiles = new Set();
+    const result = [];
+    while (true) {
+        let bestPotentialConnection;
+        for (const tile1 of cell1) {
+            for (const tile2 of cell2) {
+                if (result.some(([existingT1, existingT2]) => existingT1 === tile1 && existingT2 === tile2)) {
+                    continue;
+                }
+                if (isBlockedByWall(tile1, tile2, walls, tileSize)) {
+                    continue;
+                }
+                const heightDiff = Math.abs(tile1.y - tile2.y);
+                if (heightDiff > tileSize * MAX_AUTO_CONNECT_HEIGHT_DIFF_RATIO || tile1.type !== tile2.type) {
+                    if (connectedTiles.has(tile1) || connectedTiles.has(tile2)) {
+                        continue;
+                    }
+                }
+                const newConnection = [tile1, tile2];
+                if (bestPotentialConnection != null && !isBetterConnection(newConnection, bestPotentialConnection, tileSize)) {
+                    continue;
+                }
+                bestPotentialConnection = [tile1, tile2];
+            }
+        }
+        if (bestPotentialConnection == null ||
+            Math.abs(bestPotentialConnection[0].y - bestPotentialConnection[1].y) >=
+                MAX_CONNECTION_HEIGHT_DIFF_RATIO * tileSize) {
+            break;
+        }
+        connectedTiles.add(bestPotentialConnection[0]);
+        connectedTiles.add(bestPotentialConnection[1]);
+        result.push(bestPotentialConnection);
+    }
+    return result;
+}
+function computeConnectedTiles(originTile, connections, filter) {
+    // Build Adjacency List for O(1) lookup
+    const adjacency = new Map();
+    for (const [t1, t2] of connections) {
+        if (!adjacency.has(t1))
+            adjacency.set(t1, []);
+        if (!adjacency.has(t2))
+            adjacency.set(t2, []);
+        adjacency.get(t1).push(t2);
+        adjacency.get(t2).push(t1);
+    }
+    const visited = new Set([originTile]);
+    const queue = [originTile];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const neighbors = adjacency.get(current);
+        if (neighbors == null)
+            continue;
+        for (const neighbor of neighbors) {
+            if (visited.has(neighbor)) {
+                continue;
+            }
+            if (filter?.(neighbor) === false) {
+                continue;
+            }
+            visited.add(neighbor);
+            queue.push(neighbor);
+        }
+    }
+    return Array.from(visited);
+}
+const directions = {
+    Top: 0,
+    TopRight: 1,
+    Right: 2,
+    BottomRight: 3,
+    Bottom: 4,
+    BottomLeft: 5,
+    Left: 6,
+    TopLeft: 7,
+};
+const directionXConnectionIndexOffsetMap = {
+    [directions.Top]: [],
+    [directions.TopRight]: [
+        [0, -1],
+        [0, 0],
+    ],
+    [directions.Right]: [[0, 0]],
+    [directions.BottomRight]: [
+        [0, 0],
+        [0, 1],
+    ],
+    [directions.Bottom]: [],
+    [directions.BottomLeft]: [
+        [-1, 0],
+        [-1, 1],
+    ],
+    [directions.Left]: [[-1, 0]],
+    [directions.TopLeft]: [
+        [-1, -1],
+        [-1, 0],
+    ],
+};
+const directionZConnectionIndexOffsetMap = {
+    [directions.Top]: [[0, -1]],
+    [directions.TopRight]: [
+        [0, -1],
+        [1, -1],
+    ],
+    [directions.Right]: [],
+    [directions.BottomRight]: [
+        [0, 0],
+        [1, 0],
+    ],
+    [directions.Bottom]: [[0, 0]],
+    [directions.BottomLeft]: [
+        [0, 0],
+        [-1, 0],
+    ],
+    [directions.Left]: [],
+    [directions.TopLeft]: [
+        [0, -1],
+        [-1, -1],
+    ],
+};
+const directionXOffsetMap = {
+    [directions.Top]: 0,
+    [directions.TopRight]: 0.5,
+    [directions.Right]: 0.5,
+    [directions.BottomRight]: 0.5,
+    [directions.Bottom]: 0,
+    [directions.BottomLeft]: -0.5,
+    [directions.Left]: -0.5,
+    [directions.TopLeft]: -0.5,
+};
+const directionZOffsetMap = {
+    [directions.Top]: -0.5,
+    [directions.TopRight]: -0.5,
+    [directions.Right]: 0,
+    [directions.BottomRight]: 0.5,
+    [directions.Bottom]: 0.5,
+    [directions.BottomLeft]: 0.5,
+    [directions.Left]: 0,
+    [directions.TopLeft]: -0.5,
+};
+const wallDirections = ['top', 'right', 'bottom', 'left'];
+function computeMeter(type, cellIndex, cellSize, direction) {
+    const offset = direction == null ? 0 : (type === 'x' ? directionXOffsetMap : directionZOffsetMap)[direction];
+    return cellSize * (cellIndex + 0.5 + offset);
+}
+export class TilesGeometry extends BufferGeometry {
+    tiles;
+    walls;
+    mapSizeX;
+    mapSizeZ;
+    cellSizeX;
+    cellSizeZ;
+    vertices;
+    positions = [];
+    uvs = [];
+    textureStrengths = [];
+    idCounter = 0;
+    xConnections;
+    zConnections;
+    constructor(tiles, walls, mapSizeX, mapSizeZ) {
+        super();
+        this.tiles = tiles;
+        this.walls = walls;
+        this.mapSizeX = mapSizeX;
+        this.mapSizeZ = mapSizeZ;
+        this.cellSizeZ = mapSizeZ / tiles.length;
+        this.cellSizeX = mapSizeX / tiles[0].length;
+        this.zConnections = new Array(tiles.length - 1)
+            .fill(undefined)
+            .map((_, z) => new Array(tiles[0].length)
+            .fill(undefined)
+            .map((_, x) => computeConnections(tiles[z][x], tiles[z + 1][x], [...(walls[z]?.[x]?.bottom ?? []), ...(walls[z + 1]?.[x]?.top ?? [])], this.cellSizeZ)));
+        this.xConnections = new Array(tiles.length)
+            .fill(undefined)
+            .map((_, z) => new Array(tiles[0].length - 1)
+            .fill(undefined)
+            .map((_, x) => computeConnections(tiles[z][x], tiles[z][x + 1], [...(walls[z]?.[x]?.right ?? []), ...(walls[z]?.[x + 1]?.left ?? [])], this.cellSizeX)));
+        this.vertices = new Array(tiles.length * 2 + 1)
+            .fill(undefined)
+            .map(() => new Array(tiles[0].length * 2 + 1).fill(undefined).map(() => []));
+        const indices = [];
+        for (let tileIZ = 0; tileIZ < tiles.length; tileIZ++) {
+            const tileRow = tiles[tileIZ];
+            for (let tileIX = 0; tileIX < tileRow.length; tileIX++) {
+                const tileStack = tileRow[tileIX];
+                for (let tileIY = 0; tileIY < tileStack.length; tileIY++) {
+                    const centerVertexId = this.addVertex(tileIX, tileIZ, undefined, tileStack[tileIY]);
+                    for (let i = 0; i < 8; i += 2) {
+                        const a = centerVertexId;
+                        const b = this.getConnectionVertexId(tileIX, tileIY, tileIZ, (i + 0));
+                        const c = this.getConnectionVertexId(tileIX, tileIY, tileIZ, (i + 1));
+                        const d = this.getConnectionVertexId(tileIX, tileIY, tileIZ, ((i + 2) % 8));
+                        // First triangle
+                        indices.push(a, c, b);
+                        // Second triangle
+                        indices.push(a, d, c);
+                    }
+                }
+            }
+        }
+        // Set geometry attributes
+        this.setAttribute('position', new Float32BufferAttribute(this.positions, 3));
+        this.setAttribute('uv', new Float32BufferAttribute(this.uvs, 2));
+        this.setAttribute('textureStrength', new Float32BufferAttribute(this.textureStrengths, 16));
+        this.setIndex(new Uint16BufferAttribute(indices, 1));
+        this.computeVertexNormals();
+        this.computeTangents();
+    }
+    /**
+     * @param xIndex tile grid x index
+     * @param zIndex tile grid z index
+     * @param stackIndex index in the tile stack
+     * @param offsetX world unit offset from tile center X
+     * @param offsetZ world unit offset from tile center Z
+     * @param normalTarget optional target vector that will receive the interpolated face normal at the queried point
+     */
+    getHeight(xIndex, zIndex, stackIndex, offsetX, offsetZ, normalTarget) {
+        if (xIndex < 0 || xIndex >= this.tiles[0].length || zIndex < 0 || zIndex >= this.tiles.length) {
+            throw new Error(`Tile index out of bounds: (${xIndex}, ${zIndex}). Grid size: ${this.tiles[0].length}x${this.tiles.length}`);
+        }
+        const vertices = this.getVertices(xIndex, zIndex);
+        const vertex1 = vertices[stackIndex];
+        if (vertex1 == null) {
+            throw new Error(`No vertex found at stack index ${stackIndex} for tile (${xIndex}, ${zIndex}).`);
+        }
+        const centerX = computeMeter('x', xIndex, this.cellSizeX) - this.mapSizeX / 2;
+        const centerZ = computeMeter('z', zIndex, this.cellSizeZ) - this.mapSizeZ / 2;
+        const worldX = centerX + offsetX;
+        const worldZ = centerZ + offsetZ;
+        let tileOffsetX = offsetX;
+        let tileOffsetZ = offsetZ;
+        const l1Norm = Math.abs(tileOffsetX) + Math.abs(tileOffsetZ);
+        if (l1Norm > 0) {
+            tileOffsetX /= l1Norm;
+            tileOffsetZ /= l1Norm;
+        }
+        let triangleIndex = Math.abs(tileOffsetX) > Math.abs(tileOffsetZ) ? 1 : 0;
+        if (tileOffsetZ > 0) {
+            triangleIndex = 3 - triangleIndex;
+        }
+        if (tileOffsetX < 0) {
+            triangleIndex = 7 - triangleIndex;
+        }
+        const directionVertex2 = triangleIndex;
+        const directionVertex3 = ((triangleIndex + 1) % 8);
+        const tile = vertex1.relatedTiles[0];
+        const vertex2 = this.getVertices(xIndex, zIndex, directionVertex2).find((vertex) => vertex.relatedTiles.includes(tile));
+        const vertex3 = this.getVertices(xIndex, zIndex, directionVertex3).find((vertex) => vertex.relatedTiles.includes(tile));
+        if (vertex2 == null || vertex3 == null) {
+            throw new Error(`Failed to find vertices for triangle at tile (${xIndex}, ${zIndex}) stack ${stackIndex} direction ${triangleIndex}.`);
+        }
+        const [x1, y1_pos, z1] = vertex1.position;
+        const [x2, y2_pos, z2] = vertex2.position;
+        const [x3, y3_pos, z3] = vertex3.position;
+        const denom = (z2 - z3) * (x1 - x3) + (x3 - x2) * (z1 - z3);
+        let w1 = ((z2 - z3) * (worldX - x3) + (x3 - x2) * (worldZ - z3)) / denom;
+        let w2 = ((z3 - z1) * (worldX - x3) + (x1 - x3) * (worldZ - z3)) / denom;
+        // Handle potential precision issues or 0 denom (degenerate triangles shouldn't happen but safe to check?)
+        if (!Number.isFinite(w1))
+            w1 = 0;
+        if (!Number.isFinite(w2))
+            w2 = 0;
+        const w3 = 1 - w1 - w2;
+        if (normalTarget != null) {
+            const ux = x2 - x1;
+            const uy = y2_pos - y1_pos;
+            const uz = z2 - z1;
+            const vx = x3 - x1;
+            const vy = y3_pos - y1_pos;
+            const vz = z3 - z1;
+            const nx = uy * vz - uz * vy;
+            const ny = uz * vx - ux * vz;
+            const nz = ux * vy - uy * vx;
+            const lenSq = nx * nx + ny * ny + nz * nz;
+            if (lenSq > 0) {
+                normalTarget.set(nx, ny, nz).normalize().negate();
+            }
+        }
+        return w1 * y1_pos + w2 * y2_pos + w3 * y3_pos;
+    }
+    addVertex(cellIndexX, cellIndexZ, direction, tile, connections) {
+        const id = this.idCounter++;
+        const xMeter = computeMeter('x', cellIndexX, this.cellSizeX, direction);
+        const zMeter = computeMeter('z', cellIndexZ, this.cellSizeZ, direction);
+        let filteredRelatedTiles;
+        let relatedTiles;
+        if (connections == null) {
+            filteredRelatedTiles = [tile];
+            relatedTiles = [tile];
+        }
+        else {
+            relatedTiles = computeConnectedTiles(tile, connections);
+            const removeCoordinateSet = new Set();
+            let blockingTile;
+            for (const relatedTile of relatedTiles) {
+                const tileWalls = this.walls[relatedTile.cellIndexZ]?.[relatedTile.cellIndexX];
+                if (!tileWalls)
+                    continue;
+                const relevantIndices = getRelevantWallIndices(relatedTile, xMeter, zMeter, this.cellSizeX, this.cellSizeZ);
+                let causesBlocking = false;
+                for (const i of relevantIndices) {
+                    const dir = wallDirections[i];
+                    const wallSize = i % 2 === 0 ? this.cellSizeZ : this.cellSizeX;
+                    const hasBlockingWall = tileWalls[dir].some((wall) => isBlockingWall(wall, relatedTile, wallSize));
+                    if (hasBlockingWall) {
+                        causesBlocking = true;
+                        // Remove neighbor in direction i
+                        const nx = relatedTile.cellIndexX + directionXOffsetMap[(i * 2)] * 2;
+                        const nz = relatedTile.cellIndexZ + directionZOffsetMap[(i * 2)] * 2;
+                        removeCoordinateSet.add(`${nx},${nz}`);
+                        // Check secondary blocking (diagonal)
+                        const nextI = (i + 1) % 4;
+                        const nextDir = wallDirections[nextI];
+                        const nextWallSize = nextI % 2 === 0 ? this.cellSizeZ : this.cellSizeX;
+                        const hasNextBlockingWall = tileWalls[nextDir].some((wall) => isBlockingWall(wall, relatedTile, nextWallSize));
+                        if (hasNextBlockingWall) {
+                            const diagDir = (i * 2 + 1);
+                            const ndx = relatedTile.cellIndexX + directionXOffsetMap[diagDir] * 2;
+                            const ndz = relatedTile.cellIndexZ + directionZOffsetMap[diagDir] * 2;
+                            removeCoordinateSet.add(`${ndx},${ndz}`);
+                        }
+                    }
+                }
+                if (causesBlocking && blockingTile == null) {
+                    blockingTile = relatedTile;
+                }
+            }
+            filteredRelatedTiles = computeConnectedTiles(blockingTile ?? tile, connections, (newTile) => !removeCoordinateSet.has(`${newTile.cellIndexX},${newTile.cellIndexZ}`));
+        }
+        const yMeter = filteredRelatedTiles.length === 0
+            ? tile.y
+            : filteredRelatedTiles.reduce((prev, t) => prev + t.y, 0) / filteredRelatedTiles.length;
+        const textureStrength = new Array(16).fill(0);
+        const strength = relatedTiles.length === 1 ? 1 : 0.5;
+        for (const { textureId } of relatedTiles) {
+            textureStrength[textureId] = strength;
+        }
+        this.textureStrengths.push(...textureStrength);
+        const position = [xMeter - this.mapSizeX * 0.5, yMeter, zMeter - this.mapSizeZ * 0.5];
+        this.positions.push(...position);
+        const uv = [xMeter, zMeter];
+        this.uvs.push(...uv);
+        this.getVertices(cellIndexX, cellIndexZ, direction).push({
+            position,
+            textureStrength,
+            uv,
+            relatedTiles,
+            id,
+        });
+        return id;
+    }
+    getVertices(cellIndexX, cellIndexZ, direction) {
+        let vertexIndexX = cellIndexX * 2 + 1;
+        let vertexIndexZ = cellIndexZ * 2 + 1;
+        if (direction != null) {
+            vertexIndexX += directionXOffsetMap[direction] * 2;
+            vertexIndexZ += directionZOffsetMap[direction] * 2;
+        }
+        return this.vertices[vertexIndexZ][vertexIndexX];
+    }
+    getConnectionVertexId(cellIndexX, cellIndeY, cellIndexZ, direction) {
+        const tile = this.tiles[cellIndexZ][cellIndexX][cellIndeY];
+        let vertexId = this.getVertices(cellIndexX, cellIndexZ, direction).find(({ relatedTiles: connectedTiles }) => connectedTiles.includes(tile))?.id;
+        if (vertexId == null) {
+            const connections = [];
+            for (const [xOffset, zOffset] of directionXConnectionIndexOffsetMap[direction]) {
+                connections.push(...(this.xConnections[zOffset + cellIndexZ]?.[xOffset + cellIndexX] ?? []));
+            }
+            for (const [xOffset, zOffset] of directionZConnectionIndexOffsetMap[direction]) {
+                connections.push(...(this.zConnections[zOffset + cellIndexZ]?.[xOffset + cellIndexX] ?? []));
+            }
+            vertexId = this.addVertex(cellIndexX, cellIndexZ, direction, tile, connections);
+        }
+        return vertexId;
+    }
+}

package/dist/tiles/index.d.ts

@@ -0,0 +1,18 @@
+import { Material, Mesh } from 'three';
+import { Interpreter } from '../interpreter.js';
+import { coerce } from 'zod';
+export declare const groundSchema: import("zod").ZodObject<{
+    texture: import("zod").ZodString;
+    y: coerce.ZodCoercedNumber<unknown>;
+}, import("zod/v4/core").$strip>;
+export declare const ceilingSchema: import("zod").ZodObject<{
+    texture: import("zod").ZodString;
+    y: coerce.ZodCoercedNumber<unknown>;
+}, import("zod/v4/core").$strip>;
+export type TilesMeshOptions = {
+    materialSharpness?: number;
+};
+export declare class TilesMesh extends Mesh {
+    constructor(interpreter: Interpreter, material?: Material, options?: TilesMeshOptions);
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tiles/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EACR,IAAI,EAOL,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAkB,MAAM,KAAK,CAAA;AAO5C,eAAO,MAAM,YAAY;;;gCAAoD,CAAA;AAC7E,eAAO,MAAM,aAAa;;;gCAAoD,CAAA;AAE9E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA;AAyCD,qBAAa,SAAU,SAAQ,IAAI;gBACrB,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC,EAAE,OAAO,GAAE,gBAAqB;CA6GnH"}

package/dist/tiles/index.js

@@ -0,0 +1,121 @@
+import { Mesh, Texture, MeshBasicMaterial, } from 'three';
+import { coerce, object, string } from 'zod';
+import { TilesGeometry } from './geometry.js';
+import { buildTilesMaterial } from './material.js';
+import { ChartaError } from '../errors.js';
+import { wallSchema } from '../walls/index.js';
+import { buildTextureArrayFromAssets } from '../utils/texture.js';
+export const groundSchema = object({ texture: string(), y: coerce.number() });
+export const ceilingSchema = object({ texture: string(), y: coerce.number() });
+function resolveHeights(position, items, interpreter, reverse) {
+    items = [...items];
+    if (reverse) {
+        items.reverse();
+    }
+    let lastY;
+    const result = [...items].map((item) => {
+        if (item.layerY != null) {
+            lastY = item.layerY;
+            return item.layerY;
+        }
+        if (item.explicitWallY != null) {
+            return item.explicitWallY;
+        }
+        if (lastY == null) {
+            interpreter.reportError(new ChartaError(`Wall at ${position.join('/')}: ${reverse ? 'missing topY and no susequent layer' : 'missing bottomY and no preceding layer'}`, interpreter.getSource(), item.loc));
+            return undefined;
+        }
+        return lastY;
+    });
+    if (reverse) {
+        result.reverse();
+    }
+    return result;
+}
+export class TilesMesh extends Mesh {
+    constructor(interpreter, material = new MeshBasicMaterial(), options = {}) {
+        super();
+        const rows = interpreter.getRows();
+        const cols = interpreter.getCols();
+        // Helper to manage texture indices on the fly
+        const textureIndex = new Map();
+        const getTextureIndex = (name, loc) => {
+            const texture = interpreter.getAsset(Texture, `${name}BaseColorTexture`, loc);
+            if (!texture)
+                return 0;
+            let idx = textureIndex.get(texture);
+            if (idx == null) {
+                idx = textureIndex.size;
+                textureIndex.set(texture, idx);
+            }
+            return idx;
+        };
+        // Initialize grid structures
+        const tiles = Array.from({ length: rows }, () => Array.from({ length: cols }, () => []));
+        const walls = Array.from({ length: rows }, () => Array.from({ length: cols }, () => ({
+            top: [],
+            bottom: [],
+            left: [],
+            right: [],
+        })));
+        for (let z = 0; z < rows; z++) {
+            for (let x = 0; x < cols; x++) {
+                // 1. Collect all entries for this cell
+                const calls = Array.from(interpreter.getCalls([z, x], {
+                    ground: groundSchema,
+                    ceiling: ceilingSchema,
+                    wall: wallSchema,
+                }));
+                // 2. Compute wall heights using the helper
+                const bottomYs = resolveHeights([z, x], calls.map(([_1, parsed, _2, loc]) => ({
+                    loc,
+                    layerY: 'y' in parsed ? parsed.y : undefined,
+                    explicitWallY: 'bottomY' in parsed ? parsed.bottomY : undefined,
+                })), interpreter, false);
+                const topYs = resolveHeights([z, x], calls.map(([_1, parsed, _2, loc]) => ({
+                    loc,
+                    layerY: 'y' in parsed ? parsed.y : undefined,
+                    explicitWallY: 'topY' in parsed ? parsed.topY : undefined,
+                })), interpreter, true);
+                // 3. Populate data structures
+                for (let i = 0; i < calls.length; i++) {
+                    const [name, parsed, _, loc] = calls[i];
+                    if (name === 'wall') {
+                        let bottomY = bottomYs[i];
+                        let topY = topYs[i];
+                        if (bottomY === undefined || topY === undefined)
+                            continue;
+                        // Normalize heights so bottom is numerically lower
+                        if (topY < bottomY) {
+                            ;
+                            [bottomY, topY] = [topY, bottomY];
+                        }
+                        const dir = parsed.dir;
+                        if (walls[z][x][dir]) {
+                            walls[z][x][dir].push({ bottomY, topY });
+                        }
+                    }
+                    else {
+                        // Ground or Ceiling
+                        tiles[z][x].push({
+                            type: name,
+                            y: parsed.y,
+                            textureId: getTextureIndex(parsed.texture, loc),
+                            cellIndexX: x,
+                            cellIndexZ: z,
+                        });
+                    }
+                }
+            }
+        }
+        const cellSize = interpreter.getCellSize();
+        const geometry = new TilesGeometry(tiles, walls, cols * cellSize, rows * cellSize);
+        this.geometry = geometry;
+        interpreter.setAsset('tilesGeometry', geometry);
+        // Build texture array from interpreter assets using encountered material names in insertion order
+        const texturesInOrder = Array.from(textureIndex.keys()).sort((a, b) => textureIndex.get(a) - textureIndex.get(b));
+        if (texturesInOrder.length > 0) {
+            this.material = buildTilesMaterial(material, buildTextureArrayFromAssets(texturesInOrder));
+        }
+    }
+}

package/dist/tiles/material.d.ts

@@ -0,0 +1,6 @@
+import { DataArrayTexture, Material } from "three";
+/**
+ * Modifies an existing Three.js material to support texture array blending based on textureStrength
+ */
+export declare function buildTilesMaterial<T extends Material>(material: T, textureArray: DataArrayTexture): T;
+//# sourceMappingURL=material.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../src/tiles/material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEnD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,QAAQ,EACnD,QAAQ,EAAE,CAAC,EACX,YAAY,EAAE,gBAAgB,GAC7B,CAAC,CAoGH"}