@drawcall/charta 0.1.8 → 0.1.10

package/dist/grass/index.js

@@ -19,10 +19,10 @@ export class GrassMesh extends InstancedMesh {
             .fill(undefined)
             .map(() => new Array(cols).fill(null));
         let maxBlades = 0;
-        for (let z = 0; z < rows; z++) {
-            for (let x = 0; x < cols; x++) {
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
                 const grassParsed = interpreter
-                    .getCalls([z, x], { grass: grassSchema })
+                    .getCalls([row, col], { grass: grassSchema })
                     .at(-1)?.[1];
                 if (!grassParsed)
                     continue;
@@ -33,8 +33,8 @@ export class GrassMesh extends InstancedMesh {
                 const step = cellSize / subN;
                 const jitterAmp = step * 0.35;
                 // top surface stack index = total number of ground/ceiling - 1
-                const topStackIndex = Math.max(0, interpreter.countCalls([z, x], (c) => c.name === "ground" || c.name === "ceiling") - 1);
-                perCell[z][x] = {
+                const topStackIndex = Math.max(0, interpreter.countCalls([row, col], (c) => c.name === "ground" || c.name === "ceiling") - 1);
+                perCell[row][col] = {
                     subN,
                     jitterAmp,
                     height,
@@ -46,23 +46,23 @@ export class GrassMesh extends InstancedMesh {
             }
         }
         // Compute neighbor flags
-        function hasGrassCell(z, x) {
-            return (!(z < 0 || x < 0 || z >= rows || x >= cols) && perCell[z][x] != null);
+        function hasGrassCell(row, col) {
+            return (!(row < 0 || col < 0 || row >= rows || col >= cols) && perCell[row][col] != null);
         }
-        for (let z = 0; z < rows; z++) {
-            for (let x = 0; x < cols; x++) {
-                const cell = perCell[z][x];
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const cell = perCell[row][col];
                 if (!cell)
                     continue;
                 cell.neighbors = {
-                    top: !hasGrassCell(z - 1, x), // north
-                    right: !hasGrassCell(z, x + 1), // east
-                    bottom: !hasGrassCell(z + 1, x), // south
-                    left: !hasGrassCell(z, x - 1), // west
-                    topLeft: !hasGrassCell(z - 1, x - 1),
-                    topRight: !hasGrassCell(z - 1, x + 1),
-                    bottomRight: !hasGrassCell(z + 1, x + 1),
-                    bottomLeft: !hasGrassCell(z + 1, x - 1),
+                    top: !hasGrassCell(row - 1, col), // north
+                    right: !hasGrassCell(row, col + 1), // east
+                    bottom: !hasGrassCell(row + 1, col), // south
+                    left: !hasGrassCell(row, col - 1), // west
+                    topLeft: !hasGrassCell(row - 1, col - 1),
+                    topRight: !hasGrassCell(row - 1, col + 1),
+                    bottomRight: !hasGrassCell(row + 1, col + 1),
+                    bottomLeft: !hasGrassCell(row + 1, col - 1),
                 };
             }
         }
@@ -83,17 +83,17 @@ export class GrassMesh extends InstancedMesh {
         const scale = new Vector3(1, 1, 1);
         const tilesGeometry = interpreter.getAsset(TilesGeometry, "tilesGeometry");
         // Single pass generation
-        for (let z = 0; z < rows; z++) {
-            for (let x = 0; x < cols; x++) {
-                const cell = perCell[z][x];
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const cell = perCell[row][col];
                 if (!cell)
                     continue;
                 const { subN, jitterAmp, height, width, topStackIndex, neighbors } = cell;
                 const nb = neighbors;
                 const step = cellSize / subN;
                 // Cell center
-                const cx = (x - cols / 2 + 0.5) * cellSize;
-                const cz = (z - rows / 2 + 0.5) * cellSize;
+                const cx = (col - cols / 2 + 0.5) * cellSize;
+                const cz = (row - rows / 2 + 0.5) * cellSize;
                 for (let gz = 0; gz < subN; gz++) {
                     for (let gx = 0; gx < subN; gx++) {
                         // Optimization: Check stochastic rejection early using simplified fade check
@@ -144,7 +144,7 @@ export class GrassMesh extends InstancedMesh {
                         const pz = cz + oz + jz;
                         let baseY = 0;
                         if (tilesGeometry) {
-                            baseY = tilesGeometry.getHeight(x, z, topStackIndex, px - cx, pz - cz);
+                            baseY = tilesGeometry.getHeight(row, col, topStackIndex, px - cx, pz - cz);
                         }
                         tmpPos.set(px, baseY, pz);
                         // Scale

package/dist/locations.js

@@ -51,7 +51,7 @@ export class Locations {
             stackIndex = layersAfter > 0 ? 0 : 0;
         }
         const tilesGeometry = this.interpreter.getAsset(TilesGeometry, 'tilesGeometry');
-        const y = tilesGeometry?.getHeight(col, row, stackIndex, 0, 0) ?? 0;
+        const y = tilesGeometry?.getHeight(row, col, stackIndex, 0, 0) ?? 0;
         target.set(x, y, z);
         return target;
     }

package/dist/pillars/index.js

@@ -86,7 +86,7 @@ export class PillarMesh extends InstancedMesh {
                         const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry', loc);
                         if (!tilesGeometry)
                             continue;
-                        bottomY = tilesGeometry.getHeight(col, row, bottomStackIndex, offsetX, offsetZ);
+                        bottomY = tilesGeometry.getHeight(row, col, bottomStackIndex, offsetX, offsetZ);
                     }
                     let topStackIndex;
                     if (topY == null) {
@@ -100,7 +100,7 @@ export class PillarMesh extends InstancedMesh {
                         const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry', loc);
                         if (!tilesGeometry)
                             continue;
-                        topY = tilesGeometry.getHeight(col, row, topStackIndex, offsetX, offsetZ);
+                        topY = tilesGeometry.getHeight(row, col, topStackIndex, offsetX, offsetZ);
                     }
                     // Support "negative pillars" by swapping
                     if (topY < bottomY) {

package/dist/place/index.js

@@ -77,7 +77,7 @@ export class PlaceGroup extends Group {
                 py = opts.fixedY;
             }
             else {
-                py = tilesGeometry.getHeight(cell.col, cell.row, opts.layerIndex, offsetX, offsetZ, normal);
+                py = tilesGeometry.getHeight(cell.row, cell.col, opts.layerIndex, offsetX, offsetZ, normal);
             }
             const pos = new Vector3(px, py, pz);
             const quat = new Quaternion();
@@ -111,22 +111,22 @@ export class PlaceGroup extends Group {
             const scale = Math.min(sFactorX ?? sFactorZ ?? 1, sFactorZ ?? sFactorX ?? 1);
             return new Vector3(scale, scale, scale);
         };
-        for (let z = 0; z < rows; z++) {
-            for (let x = 0; x < cols; x++) {
-                const scatterEntries = interpreter.getCalls([z, x], {
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const scatterEntries = interpreter.getCalls([row, col], {
                     scatter: scatterSchema,
                 });
-                const placeEntries = interpreter.getCalls([z, x], {
+                const placeEntries = interpreter.getCalls([row, col], {
                     place: placeSchema,
                 });
                 if (scatterEntries.length === 0 && placeEntries.length === 0)
                     continue;
-                const cx = (x - cols / 2 + 0.5) * cellSize;
-                const cz = (z - rows / 2 + 0.5) * cellSize;
+                const cx = (col - cols / 2 + 0.5) * cellSize;
+                const cz = (row - rows / 2 + 0.5) * cellSize;
                 const half = cellSize * 0.5;
                 // scatter: randomized distribution, density is count for now
                 for (const [, parsed, callIdx, loc] of scatterEntries) {
-                    const layerIndex = interpreter.countCalls([z, x], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
+                    const layerIndex = interpreter.countCalls([row, col], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
                     const prefabName = `${parsed.model}Prefab`;
                     const batchBuilder = interpreter.getAsset(PrefabBatchBuilder, prefabName, loc);
                     if (!batchBuilder)
@@ -135,7 +135,7 @@ export class PlaceGroup extends Group {
                     const usualSize = new Vector3();
                     usualSize.copy(batchBuilder.prefabSize);
                     const base = hashStringToUint32(parsed.model);
-                    const seed = hashNumbersToUint32(base, z, x);
+                    const seed = hashNumbersToUint32(base, row, col);
                     const rng = createRng(seed);
                     // area-based density: items per m^2
                     // expected = density * area; stochastic rounding using seeded rng
@@ -161,7 +161,7 @@ export class PlaceGroup extends Group {
                         const px = cx + ox;
                         const pz = cz + oz;
                         const yaw = yawMin === yawMax ? yawMin : yawMin + (yawMax - yawMin) * rng();
-                        const { pos, quat, scl } = computeTransform(px, pz, { row: z, col: x, center: [cx, cz] }, {
+                        const { pos, quat, scl } = computeTransform(px, pz, { row, col, center: [cx, cz] }, {
                             alignMode,
                             yaw,
                             useFixedY: useFixedY,
@@ -181,13 +181,13 @@ export class PlaceGroup extends Group {
                 }
                 // place: exact in-cell placement
                 for (const [, parsed, callIdx, loc] of placeEntries) {
-                    const layerIndex = interpreter.countCalls([z, x], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
+                    const layerIndex = interpreter.countCalls([row, col], (c) => c.name === 'ground' || c.name === 'ceiling', 0, callIdx) - 1;
                     const px = cx + (parsed.offsetX ?? 0);
                     const pz = cz + (parsed.offsetZ ?? 0);
                     // In place command, yaw is exact, no min/max range
                     const yaw = parsed.yaw ?? 0;
                     const alignMode = (parsed.align ?? 'up').toLowerCase();
-                    const { pos, quat, scl } = computeTransform(px, pz, { row: z, col: x, center: [cx, cz] }, {
+                    const { pos, quat, scl } = computeTransform(px, pz, { row, col, center: [cx, cz] }, {
                         alignMode,
                         yaw,
                         useFixedY: parsed.bottomY != null,

package/dist/tiles/geometry.d.ts

@@ -3,8 +3,8 @@ export type Tile = {
     type: string;
     y: number;
     textureId: number;
-    cellIndexX: number;
-    cellIndexZ: number;
+    row: number;
+    col: number;
 };
 export type WallData = {
     topY: number;
@@ -31,14 +31,14 @@ export declare class TilesGeometry extends BufferGeometry {
         left: Array<WallData>;
     }>>, mapSizeX: number, mapSizeZ: number);
     /**
-     * @param xIndex tile grid x index
-     * @param zIndex tile grid z index
+     * @param row tile grid row index (Z direction)
+     * @param col tile grid column index (X direction)
      * @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: number, zIndex: number, stackIndex: number, offsetX: number, offsetZ: number, normalTarget?: Vector3): number;
+    getHeight(row: number, col: number, stackIndex?: number, offsetX?: number, offsetZ?: number, normalTarget?: Vector3): number;
     private addVertex;
     private getVertices;
     private getConnectionVertexId;

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/tiles/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAMd,OAAO,EACR,MAAM,OAAO,CAAA;AAGd,MAAM,MAAM,IAAI,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAA;AAoBzG,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAkQxD,qBAAa,aAAc,SAAQ,cAAc;IAe7C,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;aAQN,QAAQ,EAAE,MAAM;aAChB,QAAQ,EAAE,MAAM;IAxBlC,SAAgB,SAAS,EAAE,MAAM,CAAA;IACjC,SAAgB,SAAS,EAAE,MAAM,CAAA;IAEjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAoB;IACxC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoB;IAErD,OAAO,CAAC,SAAS,CAAI;IAErB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAChE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;gBAG7C,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAChC,KAAK,EAAE,KAAK,CAC3B,KAAK,CAAC;QACJ,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;QACpB,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;QACtB,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;QACvB,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;KACtB,CAAC,CACH,EACe,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM;IA0ElC;;;;;;;OAOG;IACI,SAAS,CACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,EAAE,OAAO;IAmFxB,OAAO,CAAC,SAAS;IAoGjB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,qBAAqB;CAsB9B"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/tiles/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAMd,OAAO,EACR,MAAM,OAAO,CAAA;AAGd,MAAM,MAAM,IAAI,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAoB3F,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAkQxD,qBAAa,aAAc,SAAQ,cAAc;IAe7C,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;aAQN,QAAQ,EAAE,MAAM;aAChB,QAAQ,EAAE,MAAM;IAxBlC,SAAgB,SAAS,EAAE,MAAM,CAAA;IACjC,SAAgB,SAAS,EAAE,MAAM,CAAA;IAEjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAoB;IACxC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoB;IAErD,OAAO,CAAC,SAAS,CAAI;IAErB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAChE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;gBAG7C,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAChC,KAAK,EAAE,KAAK,CAC3B,KAAK,CAAC;QACJ,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;QACpB,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;QACtB,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;QACvB,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;KACtB,CAAC,CACH,EACe,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM;IA0ElC;;;;;;;OAOG;IACI,SAAS,CACd,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,GAAE,MAAU,EACnB,OAAO,GAAE,MAAU,EACnB,YAAY,CAAC,EAAE,OAAO;IAqFxB,OAAO,CAAC,SAAS;IAoGjB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,qBAAqB;CAiB9B"}

package/dist/tiles/geometry.js

@@ -67,8 +67,8 @@ 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 centerX = computeMeter('x', tile.col, cellSizeX);
+    const centerZ = computeMeter('z', tile.row, cellSizeZ);
     const dx = vertexX - centerX;
     const dz = vertexZ - centerZ;
     const eps = 1e-3;
@@ -266,17 +266,17 @@ export class TilesGeometry extends BufferGeometry {
             .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 row = 0; row < tiles.length; row++) {
+            const tileRow = tiles[row];
+            for (let col = 0; col < tileRow.length; col++) {
+                const tileStack = tileRow[col];
+                for (let stackIdx = 0; stackIdx < tileStack.length; stackIdx++) {
+                    const centerVertexId = this.addVertex(col, row, undefined, tileStack[stackIdx]);
                     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));
+                        const b = this.getConnectionVertexId(col, stackIdx, row, (i + 0));
+                        const c = this.getConnectionVertexId(col, stackIdx, row, (i + 1));
+                        const d = this.getConnectionVertexId(col, stackIdx, row, ((i + 2) % 8));
                         // First triangle
                         indices.push(a, c, b);
                         // Second triangle
@@ -294,24 +294,24 @@ export class TilesGeometry extends BufferGeometry {
         this.computeTangents();
     }
     /**
-     * @param xIndex tile grid x index
-     * @param zIndex tile grid z index
+     * @param row tile grid row index (Z direction)
+     * @param col tile grid column index (X direction)
      * @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}`);
+    getHeight(row, col, stackIndex, offsetX = 0, offsetZ = 0, normalTarget) {
+        if (col < 0 || col >= this.tiles[0].length || row < 0 || row >= this.tiles.length) {
+            throw new Error(`Tile index out of bounds: (row=${row}, col=${col}). Grid size: ${this.tiles.length}x${this.tiles[0].length}`);
         }
-        const vertices = this.getVertices(xIndex, zIndex);
-        const vertex1 = vertices[stackIndex];
+        const vertices = this.getVertices(col, row);
+        const vertex1 = vertices[stackIndex ?? vertices.length - 1];
         if (vertex1 == null) {
-            throw new Error(`No vertex found at stack index ${stackIndex} for tile (${xIndex}, ${zIndex}).`);
+            throw new Error(`No vertex found at stack index "${stackIndex ?? 'any'}" for tile (row=${row}, col=${col}).`);
         }
-        const centerX = computeMeter('x', xIndex, this.cellSizeX) - this.mapSizeX / 2;
-        const centerZ = computeMeter('z', zIndex, this.cellSizeZ) - this.mapSizeZ / 2;
+        const centerX = computeMeter('x', col, this.cellSizeX) - this.mapSizeX / 2;
+        const centerZ = computeMeter('z', row, this.cellSizeZ) - this.mapSizeZ / 2;
         const worldX = centerX + offsetX;
         const worldZ = centerZ + offsetZ;
         let tileOffsetX = offsetX;
@@ -331,10 +331,10 @@ export class TilesGeometry extends BufferGeometry {
         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));
+        const vertex2 = this.getVertices(col, row, directionVertex2).find((vertex) => vertex.relatedTiles.includes(tile));
+        const vertex3 = this.getVertices(col, row, 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}.`);
+            throw new Error(`Failed to find vertices for triangle at tile (row=${row}, col=${col}) stack "${stackIndex ?? 'any'}" direction ${triangleIndex}.`);
         }
         const [x1, y1_pos, z1] = vertex1.position;
         const [x2, y2_pos, z2] = vertex2.position;
@@ -365,10 +365,10 @@ export class TilesGeometry extends BufferGeometry {
         }
         return w1 * y1_pos + w2 * y2_pos + w3 * y3_pos;
     }
-    addVertex(cellIndexX, cellIndexZ, direction, tile, connections) {
+    addVertex(col, row, direction, tile, connections) {
         const id = this.idCounter++;
-        const xMeter = computeMeter('x', cellIndexX, this.cellSizeX, direction);
-        const zMeter = computeMeter('z', cellIndexZ, this.cellSizeZ, direction);
+        const xMeter = computeMeter('x', col, this.cellSizeX, direction);
+        const zMeter = computeMeter('z', row, this.cellSizeZ, direction);
         let filteredRelatedTiles;
         let relatedTiles;
         if (connections == null) {
@@ -380,7 +380,7 @@ export class TilesGeometry extends BufferGeometry {
             const removeCoordinateSet = new Set();
             let blockingTile;
             for (const relatedTile of relatedTiles) {
-                const tileWalls = this.walls[relatedTile.cellIndexZ]?.[relatedTile.cellIndexX];
+                const tileWalls = this.walls[relatedTile.row]?.[relatedTile.col];
                 if (!tileWalls)
                     continue;
                 const relevantIndices = getRelevantWallIndices(relatedTile, xMeter, zMeter, this.cellSizeX, this.cellSizeZ);
@@ -392,9 +392,9 @@ export class TilesGeometry extends BufferGeometry {
                     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}`);
+                        const nc = relatedTile.col + directionXOffsetMap[(i * 2)] * 2;
+                        const nr = relatedTile.row + directionZOffsetMap[(i * 2)] * 2;
+                        removeCoordinateSet.add(`${nr},${nc}`);
                         // Check secondary blocking (diagonal)
                         const nextI = (i + 1) % 4;
                         const nextDir = wallDirections[nextI];
@@ -402,9 +402,9 @@ export class TilesGeometry extends BufferGeometry {
                         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}`);
+                            const ndc = relatedTile.col + directionXOffsetMap[diagDir] * 2;
+                            const ndr = relatedTile.row + directionZOffsetMap[diagDir] * 2;
+                            removeCoordinateSet.add(`${ndr},${ndc}`);
                         }
                     }
                 }
@@ -412,7 +412,7 @@ export class TilesGeometry extends BufferGeometry {
                     blockingTile = relatedTile;
                 }
             }
-            filteredRelatedTiles = computeConnectedTiles(blockingTile ?? tile, connections, (newTile) => !removeCoordinateSet.has(`${newTile.cellIndexX},${newTile.cellIndexZ}`));
+            filteredRelatedTiles = computeConnectedTiles(blockingTile ?? tile, connections, (newTile) => !removeCoordinateSet.has(`${newTile.row},${newTile.col}`));
         }
         const yMeter = filteredRelatedTiles.length === 0
             ? tile.y
@@ -427,7 +427,7 @@ export class TilesGeometry extends BufferGeometry {
         this.positions.push(...position);
         const uv = [xMeter, zMeter];
         this.uvs.push(...uv);
-        this.getVertices(cellIndexX, cellIndexZ, direction).push({
+        this.getVertices(col, row, direction).push({
             position,
             textureStrength,
             uv,
@@ -436,27 +436,27 @@ export class TilesGeometry extends BufferGeometry {
         });
         return id;
     }
-    getVertices(cellIndexX, cellIndexZ, direction) {
-        let vertexIndexX = cellIndexX * 2 + 1;
-        let vertexIndexZ = cellIndexZ * 2 + 1;
+    getVertices(col, row, direction) {
+        let vertexCol = col * 2 + 1;
+        let vertexRow = row * 2 + 1;
         if (direction != null) {
-            vertexIndexX += directionXOffsetMap[direction] * 2;
-            vertexIndexZ += directionZOffsetMap[direction] * 2;
+            vertexCol += directionXOffsetMap[direction] * 2;
+            vertexRow += directionZOffsetMap[direction] * 2;
         }
-        return this.vertices[vertexIndexZ][vertexIndexX];
+        return this.vertices[vertexRow][vertexCol];
     }
-    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;
+    getConnectionVertexId(col, stackIndex, row, direction) {
+        const tile = this.tiles[row][col][stackIndex];
+        let vertexId = this.getVertices(col, row, 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] ?? []));
+                connections.push(...(this.xConnections[zOffset + row]?.[xOffset + col] ?? []));
             }
             for (const [xOffset, zOffset] of directionZConnectionIndexOffsetMap[direction]) {
-                connections.push(...(this.zConnections[zOffset + cellIndexZ]?.[xOffset + cellIndexX] ?? []));
+                connections.push(...(this.zConnections[zOffset + row]?.[xOffset + col] ?? []));
             }
-            vertexId = this.addVertex(cellIndexX, cellIndexZ, direction, tile, connections);
+            vertexId = this.addVertex(col, row, direction, tile, connections);
         }
         return vertexId;
     }

package/dist/tiles/index.d.ts

@@ -1,6 +1,7 @@
 import { Material, Mesh } from 'three';
 import { Interpreter } from '../interpreter.js';
 import { coerce } from 'zod';
+import { TilesGeometry } from './geometry.js';
 export declare const groundSchema: import("zod").ZodObject<{
     texture: import("zod").ZodString;
     y: coerce.ZodCoercedNumber<unknown>;
@@ -9,10 +10,8 @@ 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 {
+export type TilesMeshOptions = {};
+export declare class TilesMesh extends Mesh<TilesGeometry> {
     constructor(interpreter: Interpreter, material?: Material, options?: TilesMeshOptions);
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"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;AAC5C,OAAO,EAAE,aAAa,EAAuB,MAAM,eAAe,CAAA;AAMlE,eAAO,MAAM,YAAY;;;gCAAoD,CAAA;AAC7E,eAAO,MAAM,aAAa;;;gCAAoD,CAAA;AAE9E,MAAM,MAAM,gBAAgB,GAAG,EAAE,CAAA;AAyCjC,qBAAa,SAAU,SAAQ,IAAI,CAAC,aAAa,CAAC;gBACpC,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC,EAAE,OAAO,GAAE,gBAAqB;CA4GnH"}

package/dist/tiles/index.js

@@ -34,7 +34,6 @@ function resolveHeights(position, items, interpreter, reverse) {
 }
 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
@@ -58,21 +57,21 @@ export class TilesMesh extends Mesh {
             left: [],
             right: [],
         })));
-        for (let z = 0; z < rows; z++) {
-            for (let x = 0; x < cols; x++) {
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
                 // 1. Collect all entries for this cell
-                const calls = Array.from(interpreter.getCalls([z, x], {
+                const calls = Array.from(interpreter.getCalls([row, col], {
                     ground: groundSchema,
                     ceiling: ceilingSchema,
                     wall: wallSchema,
                 }));
                 // 2. Compute wall heights using the helper
-                const bottomYs = resolveHeights([z, x], calls.map(([_1, parsed, _2, loc]) => ({
+                const bottomYs = resolveHeights([row, col], 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]) => ({
+                const topYs = resolveHeights([row, col], calls.map(([_1, parsed, _2, loc]) => ({
                     loc,
                     layerY: 'y' in parsed ? parsed.y : undefined,
                     explicitWallY: 'topY' in parsed ? parsed.topY : undefined,
@@ -91,18 +90,18 @@ export class TilesMesh extends Mesh {
                             [bottomY, topY] = [topY, bottomY];
                         }
                         const dir = parsed.dir;
-                        if (walls[z][x][dir]) {
-                            walls[z][x][dir].push({ bottomY, topY });
+                        if (walls[row][col][dir]) {
+                            walls[row][col][dir].push({ bottomY, topY });
                         }
                     }
                     else {
                         // Ground or Ceiling
-                        tiles[z][x].push({
+                        tiles[row][col].push({
                             type: name,
                             y: parsed.y,
                             textureId: getTextureIndex(parsed.texture, loc),
-                            cellIndexX: x,
-                            cellIndexZ: z,
+                            row,
+                            col,
                         });
                     }
                 }
@@ -110,7 +109,7 @@ export class TilesMesh extends Mesh {
         }
         const cellSize = interpreter.getCellSize();
         const geometry = new TilesGeometry(tiles, walls, cols * cellSize, rows * cellSize);
-        this.geometry = geometry;
+        super(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));

package/dist/walls/index.js

@@ -129,7 +129,7 @@ export function computeWallVerticalBounds(interpreter, tilesGeometry, row, col,
         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);
+            yStart[k] = tilesGeometry.getHeight(bottomLayer.row, bottomLayer.col, bottomLayer.layerIdx, offX, offZ);
         }
         else {
             yStart[k] = parsed.bottomY;
@@ -138,7 +138,7 @@ export function computeWallVerticalBounds(interpreter, tilesGeometry, row, col,
         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);
+            yEnd[k] = tilesGeometry.getHeight(topLayer.row, topLayer.col, topLayer.layerIdx, offX, offZ);
         }
         else {
             yEnd[k] = parsed.topY;

package/dist/water/index.js

@@ -6,24 +6,24 @@ 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
+        // Build tiles[row][col] => 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 });
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const entries = interpreter.getCalls([row, col], { water: waterSchema });
                 const stack = [];
                 for (const [, parsed] of entries) {
                     stack.push({
                         type: "water",
                         y: parsed.y,
                         textureId: 0,
-                        cellIndexX: x,
-                        cellIndexZ: z,
+                        row,
+                        col,
                     });
                 }
-                tiles[z][x] = stack;
+                tiles[row][col] = stack;
             }
         }
         const cellSize = interpreter.getCellSize();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drawcall/charta",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "author": "Bela Bohlender",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://drawcall.ai",