@drawcall/charta 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./parser.js";
+export * from "./interpreter.js";
+export * from "./tiles/index.js";
+export * from "./walls/index.js";
+export * from "./grass/index.js";
+export * from "./place/index.js";
+export * from "./errors.js";
+export * from "./pillars/index.js";
+export * from "./water/index.js";
+export * from "./locations.js";
+export * from "./utils/instanced-mesh-group.js";
+export * from "./assets/loader.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oBAAoB,CAAA"}

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from "./parser.js";
+export * from "./interpreter.js";
+export * from "./tiles/index.js";
+export * from "./walls/index.js";
+export * from "./grass/index.js";
+export * from "./place/index.js";
+export * from "./errors.js";
+export * from "./pillars/index.js";
+export * from "./water/index.js";
+export * from "./locations.js";
+export * from "./utils/instanced-mesh-group.js";
+export * from "./assets/loader.js";

package/dist/interpreter.d.ts

@@ -0,0 +1,47 @@
+import { coerce, output, ZodObject } from 'zod';
+import { Call } from './parser.js';
+import { ChartaError, ErrorLocation } from './errors.js';
+export declare const cellSizeFunctionParams: ZodObject<{
+    size: coerce.ZodCoercedNumber<unknown>;
+}, import("zod/v4/core").$strip>;
+export type InterpreterOptions = {
+    throwOnError?: boolean;
+};
+export declare class Interpreter {
+    private readonly ast;
+    private readonly assets;
+    private readonly source;
+    private errors;
+    private throwOnError;
+    constructor(ast: Call[][][], assets: Record<string, any> | undefined, source: string, options?: InterpreterOptions);
+    reportError(error: ChartaError): void;
+    getErrors(): ChartaError[];
+    private readonly normalizedSource;
+    private readonly sourceLines;
+    getSource(): string;
+    getLineTextForRow(row: number): string;
+    getWorldCellCenter(row: number, col: number): [number, number];
+    getRows(): number;
+    getCols(): number;
+    countCalls(index: [number, number] | undefined, filter: string | ((call: Call) => boolean), startAt?: number, endAtExcl?: number): number;
+    getCalls<T extends {
+        [Key in string]: ZodObject<any>;
+    }>(index: [number, number] | undefined, callSchemas: T): Array<{
+        [Key in keyof T]: [Key, output<T[Key]>, number, {
+            line: number;
+            column: number;
+            lineText: string;
+        }];
+    }[keyof T]>;
+    private getCellBounds;
+    private computeCallStartColumns;
+    getOptionalAsset<T>(constructor: {
+        new (...args: Array<any>): T;
+    }, name?: string): T | undefined;
+    getAsset<T>(constructor: {
+        new (...args: Array<any>): T;
+    }, name?: string, loc?: ErrorLocation): T | undefined;
+    setAsset(name: string, value: any): void;
+    getCellSize(): number;
+}
+//# sourceMappingURL=interpreter.d.ts.map

package/dist/interpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../src/interpreter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,EAAE,SAAS,EAAa,MAAM,KAAK,CAAA;AAClE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAClC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAExD,eAAO,MAAM,sBAAsB;;gCAAoC,CAAA;AAEvE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,qBAAa,WAAW;IAKpB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,YAAY,CAAS;gBAGV,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAK,EAChC,MAAM,EAAE,MAAM,EAC/B,OAAO,GAAE,kBAAuB;IAelC,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAOrC,SAAS,IAAI,WAAW,EAAE;IAI1B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IACzC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IAEtC,SAAS,IAAI,MAAM;IAInB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAMtC,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAO9D,OAAO,IAAI,MAAM;IAKjB,OAAO,IAAI,MAAM;IAKjB,UAAU,CACR,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACnC,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,EAC1C,OAAO,GAAE,MAAU,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM;IAgBT,QAAQ,CAAC,CAAC,SAAS;SAAG,GAAG,IAAI,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC;KAAE,EACpD,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACnC,WAAW,EAAE,CAAC,GACb,KAAK,CACN;SACG,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KACpG,CAAC,MAAM,CAAC,CAAC,CACX;IA0GD,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,uBAAuB;IAa/B,gBAAgB,CAAC,CAAC,EAAE,WAAW,EAAE;QAAE,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;KAAE,EAAE,IAAI,GAAE,MAAyB,GAAG,CAAC,GAAG,SAAS;IAWlH,QAAQ,CAAC,CAAC,EACR,WAAW,EAAE;QAAE,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;KAAE,EAC7C,IAAI,GAAE,MAAyB,EAC/B,GAAG,CAAC,EAAE,aAAa,GAClB,CAAC,GAAG,SAAS;IAmBhB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAIxC,WAAW,IAAI,MAAM;CAStB"}

package/dist/interpreter.js

@@ -0,0 +1,226 @@
+import { coerce, object } from 'zod';
+import { ChartaError } from './errors.js';
+export const cellSizeFunctionParams = object({ size: coerce.number() });
+export class Interpreter {
+    ast;
+    assets;
+    source;
+    errors = [];
+    throwOnError;
+    constructor(ast, assets = {}, source, options = {}) {
+        this.ast = ast;
+        this.assets = assets;
+        this.source = source;
+        this.throwOnError = options.throwOnError ?? true;
+        this.normalizedSource = this.source.replace(/\r\n?/g, '\n');
+        this.sourceLines = this.normalizedSource.split('\n');
+        if (this.ast.length === 0) {
+            this.reportError(new ChartaError(`Charta files must have atleast one line. Meta row is missing.`, this.normalizedSource, {
+                line: 1,
+                column: 1,
+            }));
+        }
+    }
+    reportError(error) {
+        this.errors.push(error);
+        if (this.throwOnError) {
+            throw error;
+        }
+    }
+    getErrors() {
+        return this.errors;
+    }
+    normalizedSource;
+    sourceLines;
+    getSource() {
+        return this.normalizedSource;
+    }
+    getLineTextForRow(row) {
+        // row is zero-based (grid row), line number is row+2
+        const lineNumber = row + 2;
+        return this.sourceLines[lineNumber - 1] ?? '';
+    }
+    getWorldCellCenter(row, col) {
+        const cellSize = this.getCellSize();
+        const worldCellCenterX = (col - this.getCols() / 2 + 0.5) * cellSize;
+        const worldCellCenterZ = (row - this.getRows() / 2 + 0.5) * cellSize;
+        return [worldCellCenterX, worldCellCenterZ];
+    }
+    getRows() {
+        // Exclude meta row
+        return this.ast.length - 1;
+    }
+    getCols() {
+        // Use first grid row, if present
+        return this.ast.length > 1 ? this.ast[1].length : 0;
+    }
+    countCalls(index, filter, startAt = 0, endAtExcl) {
+        let sum = 0;
+        const calls = index == null ? this.ast[0][0] : this.ast[index[0] + 1][index[1]];
+        const length = Math.min(endAtExcl ?? Infinity, calls.length);
+        for (let i = startAt; i < length; i++) {
+            if (typeof filter === 'string' && calls[i].name != filter) {
+                continue;
+            }
+            if (typeof filter === 'function' && !filter(calls[i])) {
+                continue;
+            }
+            sum++;
+        }
+        return sum;
+    }
+    getCalls(index, callSchemas) {
+        let calls;
+        const normalizedSource = this.normalizedSource;
+        const sourceLines = this.sourceLines;
+        let lineNumber = 1;
+        let lineText = sourceLines[0] ?? '';
+        let callStartColumns = [];
+        if (index == null) {
+            calls = this.ast[0][0];
+            callStartColumns = this.computeCallStartColumns(lineText);
+        }
+        else {
+            const row = index[0] + 1;
+            const col = index[1];
+            if (row >= this.ast.length || col >= this.ast[row].length) {
+                const lineNumber = index[0] + 2;
+                const lineText = sourceLines[lineNumber - 1] ?? '';
+                this.reportError(new ChartaError(`index ${col}/${row} cannot be used to index the ast (${this.ast.length}/${this.ast[Math.min(1, this.ast.length - 1)].length})`, normalizedSource, { line: lineNumber, column: 1, lineText }));
+                return []; // Return empty if index invalid
+            }
+            calls = this.ast[row][col];
+            lineNumber = index[0] + 2;
+            lineText = sourceLines[lineNumber - 1] ?? '';
+            const [cellStart, cellEnd] = this.getCellBounds(lineText, col);
+            const cellText = lineText.slice(cellStart, cellEnd);
+            callStartColumns = this.computeCallStartColumns(cellText).map((c) => c + cellStart);
+        }
+        return calls
+            .map((call, callIdx) => {
+            if (!(call.name in callSchemas)) {
+                return false;
+            }
+            const key = call.name;
+            const callSchema = callSchemas[key];
+            const result = {};
+            const entries = Object.entries(callSchema.shape);
+            for (let i = 0; i < call.locationParams.length; i++) {
+                if (i >= entries.length) {
+                    const columnNumber = callStartColumns[callIdx] ?? 1;
+                    this.reportError(new ChartaError(`unknown param for function "${call.name}" at index "${i}", expected max "${entries.length}" but received "${call.locationParams.length}"`, normalizedSource, { line: lineNumber, column: columnNumber, lineText }));
+                    return false; // Skip this call
+                }
+                const [name, schema] = entries[i];
+                const parseResult = schema.safeParse(call.locationParams[i]);
+                if (parseResult.success) {
+                    result[name] = parseResult.data;
+                }
+                else {
+                    const columnNumber = callStartColumns[callIdx] ?? 1;
+                    this.reportError(new ChartaError(`Invalid value for param "${name}": ${parseResult.error.message}`, normalizedSource, {
+                        line: lineNumber,
+                        column: columnNumber,
+                        lineText,
+                    }));
+                    return false;
+                }
+            }
+            for (const [keyName, value] of call.keyParams) {
+                const entry = entries.find(([name]) => name === keyName);
+                if (entry == null) {
+                    const columnNumber = callStartColumns[callIdx] ?? 1;
+                    this.reportError(new ChartaError(`unknown param "${keyName}" for function "${call.name}"`, normalizedSource, {
+                        line: lineNumber,
+                        column: columnNumber,
+                        lineText,
+                    }));
+                    return false;
+                }
+                const [name, schema] = entry;
+                const parseResult = schema.safeParse(value);
+                if (parseResult.success) {
+                    result[name] = parseResult.data;
+                }
+                else {
+                    const columnNumber = callStartColumns[callIdx] ?? 1;
+                    this.reportError(new ChartaError(`Invalid value for param "${name}": ${parseResult.error.message}`, normalizedSource, {
+                        line: lineNumber,
+                        column: columnNumber,
+                        lineText,
+                    }));
+                    return false;
+                }
+            }
+            const columnNumber = callStartColumns[callIdx] ?? 1;
+            return [key, result, callIdx, { line: lineNumber, column: columnNumber, lineText }];
+        })
+            .filter((value) => value != false);
+    }
+    getCellBounds(lineText, targetCellIndex) {
+        let currentCell = 0;
+        let start = 0;
+        for (let i = 0; i <= lineText.length; i++) {
+            if (i === lineText.length || lineText[i] === '|') {
+                if (currentCell === targetCellIndex) {
+                    let s = start;
+                    while (s < i && /\s/.test(lineText[s]))
+                        s++;
+                    let e = i;
+                    while (e > s && /\s/.test(lineText[e - 1]))
+                        e--;
+                    return [s, e];
+                }
+                currentCell++;
+                start = i + 1;
+            }
+        }
+        return [0, lineText.length];
+    }
+    computeCallStartColumns(text) {
+        const columns = [];
+        const re = /[a-z0-9_\/-]+\s*\(/g;
+        let m;
+        while ((m = re.exec(text)) != null) {
+            const match = m[0];
+            const identStartOffset = match.search(/[a-z0-9_\/-]/);
+            const col = m.index + identStartOffset + 1; // 1-based
+            columns.push(col);
+        }
+        return columns;
+    }
+    getOptionalAsset(constructor, name = constructor.name) {
+        const asset = this.assets[name];
+        if (asset == null) {
+            return undefined;
+        }
+        if (!(asset instanceof constructor)) {
+            return undefined;
+        }
+        return asset;
+    }
+    getAsset(constructor, name = constructor.name, loc) {
+        const asset = this.assets[name];
+        if (asset == null) {
+            this.reportError(new ChartaError(`unknown asset "${name}"`, this.normalizedSource, loc));
+            return undefined;
+        }
+        if (!(asset instanceof constructor)) {
+            this.reportError(new ChartaError(`expected the type ${constructor.name} for asset "${name}"`, this.normalizedSource, loc));
+            return undefined;
+        }
+        return asset;
+    }
+    setAsset(name, value) {
+        this.assets[name] = value;
+    }
+    getCellSize() {
+        let cellSize = 1;
+        for (const [, { size }] of this.getCalls(undefined, {
+            cellSize: cellSizeFunctionParams,
+        })) {
+            cellSize = size;
+        }
+        return cellSize;
+    }
+}

package/dist/locations.d.ts

@@ -0,0 +1,16 @@
+import { Interpreter } from './interpreter.js';
+import { Vector3 } from 'three';
+export declare class Locations {
+    private readonly interpreter;
+    private readonly nameToCell;
+    constructor(interpreter: Interpreter);
+    /**
+     * Resolve a named location to a world-space position (x, y, z).
+     * - X/Z are the center of the owning cell.
+     * - Y is sampled from the nearest relevant layer stack at that cell.
+     *
+     * If terrain data is unavailable, Y defaults to 0.
+     */
+    getWorldPosition(name: string, target: Vector3): Vector3;
+}
+//# sourceMappingURL=locations.d.ts.map

package/dist/locations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locations.d.ts","sourceRoot":"","sources":["../src/locations.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAG9C,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAI/B,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,WAAW;IAFxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;gBAEhC,WAAW,EAAE,WAAW;IAsBrD;;;;;;OAMG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO;CAwBzD"}

package/dist/locations.js

@@ -0,0 +1,58 @@
+import { object, string } from 'zod';
+import { TilesGeometry } from './tiles/geometry.js';
+import { ChartaError } from './errors.js';
+export class Locations {
+    interpreter;
+    nameToCell = new Map();
+    constructor(interpreter) {
+        this.interpreter = interpreter;
+        const rows = interpreter.getRows();
+        const cols = interpreter.getCols();
+        const locationSchema = object({ name: string() });
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const entries = interpreter.getCalls([row, col], {
+                    location: locationSchema,
+                });
+                for (const [, parsed, callIdx, loc] of entries) {
+                    const name = parsed.name;
+                    if (this.nameToCell.has(name)) {
+                        interpreter.reportError(new ChartaError(`duplicate location "${name}"`, interpreter.getSource(), loc));
+                        continue;
+                    }
+                    this.nameToCell.set(name, { row, col, callIdx });
+                }
+            }
+        }
+    }
+    /**
+     * Resolve a named location to a world-space position (x, y, z).
+     * - X/Z are the center of the owning cell.
+     * - Y is sampled from the nearest relevant layer stack at that cell.
+     *
+     * If terrain data is unavailable, Y defaults to 0.
+     */
+    getWorldPosition(name, target) {
+        const cellLoc = this.nameToCell.get(name);
+        if (!cellLoc) {
+            throw new Error(`Unknown location "${name}".`);
+        }
+        const { row, col, callIdx } = cellLoc;
+        const [x, z] = this.interpreter.getWorldCellCenter(row, col);
+        // Determine the stack index similarly to how walls/pillars derive defaults.
+        const isLayer = (c) => c.name === 'ground' || c.name === 'ceiling';
+        const layersBefore = this.interpreter.countCalls([row, col], isLayer, 0, callIdx);
+        let stackIndex;
+        if (layersBefore > 0) {
+            stackIndex = layersBefore - 1;
+        }
+        else {
+            const layersAfter = this.interpreter.countCalls([row, col], isLayer, callIdx + 1);
+            stackIndex = layersAfter > 0 ? 0 : 0;
+        }
+        const tilesGeometry = this.interpreter.getAsset(TilesGeometry, 'tilesGeometry');
+        const y = tilesGeometry?.getHeight(col, row, stackIndex, 0, 0) ?? 0;
+        target.set(x, y, z);
+        return target;
+    }
+}

package/dist/parser.d.ts

@@ -0,0 +1,9 @@
+export type KeyParam = [key: string, value: string];
+export type Call = {
+    name: string;
+    locationParams: string[];
+    keyParams: KeyParam[];
+    offset: number;
+};
+export declare function parse(input: string): Call[][][];
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AACpD,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAKF,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,CA0C/C"}

package/dist/parser.js

@@ -0,0 +1,47 @@
+import nearley from "nearley";
+const { Parser, Grammar } = nearley;
+import grammar from "./grammar.js";
+import { ChartaError } from "./errors.js";
+export function parse(input) {
+    const normalized = input.replace(/\r\n?/g, "\n");
+    const parser = new Parser(Grammar.fromCompiled(grammar));
+    let rows;
+    try {
+        rows = parser.feed(normalized).finish()[0];
+    }
+    catch (error) {
+        const loc = typeof error.offset === 'number'
+            ? getLoc(normalized, error.offset)
+            : undefined;
+        throw new ChartaError(error.message || "Parse error", input, loc);
+    }
+    if (!rows || rows.length === 0)
+        return [];
+    // Validate Meta Row (first row)
+    if (rows[0].length !== 1) {
+        throwError(input, rows[0].offset, `First row must contain exactly one cell (meta row), found ${rows[0].length}`);
+    }
+    // Validate Grid Rows (subsequent rows)
+    // All grid rows must have the same number of cells as the first grid row
+    if (rows.length > 1) {
+        const gridRows = rows.slice(1);
+        const expectedWidth = gridRows[0].length;
+        const badRowIdx = gridRows.findIndex(r => r.length !== expectedWidth);
+        if (badRowIdx !== -1) {
+            throwError(input, gridRows[badRowIdx].offset, `Row ${badRowIdx + 2} has ${gridRows[badRowIdx].length} cells; expected ${expectedWidth}`);
+        }
+    }
+    return rows;
+}
+function throwError(input, offset, message) {
+    throw new ChartaError(message, input, getLoc(input, offset));
+}
+function getLoc(input, offset) {
+    const clampedOffset = Math.max(0, Math.min(offset, input.length));
+    const prefix = input.slice(0, clampedOffset);
+    const lines = prefix.split('\n');
+    return {
+        line: lines.length,
+        column: lines[lines.length - 1].length + 1
+    };
+}

package/dist/pillars/index.d.ts

@@ -0,0 +1,7 @@
+import { InstancedMesh, Material } from 'three';
+import { Interpreter } from '../interpreter.js';
+export type PillarCorner = 'topleft' | 'topright' | 'bottomright' | 'bottomleft';
+export declare class PillarMesh extends InstancedMesh {
+    constructor(interpreter: Interpreter, material?: Material);
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pillars/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAEb,QAAQ,EAMT,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAO/C,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,UAAU,GAAG,aAAa,GAAG,YAAY,CAAA;AAuBhF,qBAAa,UAAW,SAAQ,aAAa;gBAC/B,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC;CAoKnF"}

package/dist/pillars/index.js

@@ -0,0 +1,154 @@
+import { BoxGeometry, InstancedMesh, InstancedBufferAttribute, Matrix4, MeshBasicMaterial, Quaternion, Vector3, Texture, } from 'three';
+import { TilesGeometry } from '../tiles/geometry.js';
+import { coerce, object, string, z } from 'zod';
+import { buildTextureArrayFromAssets } from '../utils/texture.js';
+import { buildPillarMeshMaterial } from './material.js';
+import { ChartaError } from '../errors.js';
+const cornerEnum = z.enum(['topleft', 'topright', 'bottomright', 'bottomleft']);
+const pillarSchema = object({
+    corner: cornerEnum, // positional 0
+    texture: string(), // positional 1
+    sizeX: coerce.number().optional(),
+    sizeZ: coerce.number().optional(),
+    bottomY: coerce.number().optional(),
+    topY: coerce.number().optional(),
+});
+export class PillarMesh extends InstancedMesh {
+    constructor(interpreter, material = new MeshBasicMaterial()) {
+        const rows = interpreter.getRows();
+        const cols = interpreter.getCols();
+        const cellSize = interpreter.getCellSize();
+        // Collect pillar instances with resolved heights
+        const pillars = [];
+        // tilesGeometry is only required for height sampling; fetch lazily where needed
+        const usedTextures = [];
+        const getTextureId = (name) => {
+            const texture = interpreter.getAsset(Texture, `${name}BaseColorTexture`);
+            if (!texture)
+                return 0;
+            let idx = usedTextures.indexOf(texture);
+            if (idx === -1) {
+                idx = usedTextures.length;
+                usedTextures.push(texture);
+            }
+            return idx;
+        };
+        function resolveCornerPosition(row, col, corner) {
+            const [cx, cz] = interpreter.getWorldCellCenter(row, col);
+            const half = cellSize * 0.5;
+            switch (corner) {
+                case 'topleft':
+                    return [cx - half, cz - half];
+                case 'topright':
+                    return [cx + half, cz - half];
+                case 'bottomright':
+                    return [cx + half, cz + half];
+                case 'bottomleft':
+                    return [cx - half, cz + half];
+                default: {
+                    const lineNumber = row + 2;
+                    const lineText = interpreter.getLineTextForRow(row);
+                    const pos = lineText.indexOf('pillar(');
+                    const columnNumber = pos >= 0 ? pos + 1 : 1;
+                    interpreter.reportError(new ChartaError(`pillar at ${row}/${col}: invalid corner "${corner}", expected one of topleft, topright, bottomright, bottomleft`, interpreter.getSource(), { line: lineNumber, column: columnNumber, lineText }));
+                    return undefined;
+                }
+            }
+        }
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const entries = interpreter.getCalls([row, col], {
+                    pillar: pillarSchema,
+                });
+                for (const [, parsed, idx, loc] of entries) {
+                    const sizeX = Math.max(1e-4, parsed.sizeX ?? 0.2);
+                    const sizeZ = Math.max(1e-4, parsed.sizeZ ?? 0.2);
+                    const cornerPos = resolveCornerPosition(row, col, parsed.corner);
+                    if (!cornerPos)
+                        continue;
+                    const [px, pz] = cornerPos;
+                    const [cx, cz] = interpreter.getWorldCellCenter(row, col);
+                    const offsetX = px - cx;
+                    const offsetZ = pz - cz;
+                    const textureId = getTextureId(parsed.texture);
+                    // Derive default layers relative to call position (like walls)
+                    const isLayer = (c) => c.name === 'ground' || c.name === 'ceiling';
+                    let bottomY = parsed.bottomY;
+                    let topY = parsed.topY;
+                    let bottomStackIndex;
+                    if (bottomY == null) {
+                        const layersBefore = interpreter.countCalls([row, col], isLayer, 0, idx);
+                        bottomStackIndex = layersBefore - 1;
+                        if (bottomStackIndex < 0) {
+                            interpreter.reportError(new ChartaError(`pillar at ${row}/${col}: missing bottomY and no preceding layer`, interpreter.getSource(), loc));
+                            continue;
+                        }
+                        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry', loc);
+                        if (!tilesGeometry)
+                            continue;
+                        bottomY = tilesGeometry.getHeight(col, row, bottomStackIndex, offsetX, offsetZ);
+                    }
+                    let topStackIndex;
+                    if (topY == null) {
+                        const layersAfter = interpreter.countCalls([row, col], isLayer, idx + 1);
+                        if (layersAfter <= 0) {
+                            interpreter.reportError(new ChartaError(`pillar at ${row}/${col}: missing topY and no subsequent layer`, interpreter.getSource(), loc));
+                            continue;
+                        }
+                        const layersBefore = interpreter.countCalls([row, col], isLayer, 0, idx);
+                        topStackIndex = layersBefore;
+                        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry', loc);
+                        if (!tilesGeometry)
+                            continue;
+                        topY = tilesGeometry.getHeight(col, row, topStackIndex, offsetX, offsetZ);
+                    }
+                    // Support "negative pillars" by swapping
+                    if (topY < bottomY) {
+                        const tmp = bottomY;
+                        bottomY = topY;
+                        topY = tmp;
+                    }
+                    pillars.push({
+                        x: px,
+                        z: pz,
+                        sizeX,
+                        sizeZ,
+                        bottomY: bottomY,
+                        topY: topY,
+                        textureId,
+                    });
+                }
+            }
+        }
+        // Base cube with base at y=0 for easy scaling
+        const geometry = new BoxGeometry(1, 1, 1);
+        geometry.translate(0, 0.5, 0);
+        super(geometry, material, pillars.length);
+        const tmpPos = new Vector3();
+        const tmpQuat = new Quaternion();
+        const tmpScale = new Vector3();
+        const tmpMat = new Matrix4();
+        // Per-instance transforms and material indices
+        if (pillars.length > 0) {
+            const texIds = new Float32Array(pillars.length);
+            for (let i = 0; i < pillars.length; i++) {
+                const p = pillars[i];
+                const height = Math.max(0, p.topY - p.bottomY);
+                tmpPos.set(p.x, p.bottomY, p.z);
+                tmpQuat.identity();
+                tmpScale.set(p.sizeX, height, p.sizeZ);
+                tmpMat.compose(tmpPos, tmpQuat, tmpScale);
+                this.setMatrixAt(i, tmpMat);
+                texIds[i] = p.textureId;
+            }
+            ;
+            this.geometry.setAttribute('instanceTextureId', new InstancedBufferAttribute(texIds, 1));
+        }
+        this.instanceMatrix.needsUpdate = true;
+        // Texture array setup (if materials used)
+        if (usedTextures.length > 0) {
+            const textureArray = buildTextureArrayFromAssets(usedTextures);
+            buildPillarMeshMaterial(this.material, textureArray);
+        }
+    }
+}

package/dist/pillars/material.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../src/pillars/material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,GAAG,GAChB,IAAI,CAmDN"}