@drawcall/charta 0.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2024 drawcall.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/assets/loader.d.ts

@@ -0,0 +1,21 @@
+import { Group } from 'three';
+import { Interpreter } from '../interpreter.js';
+export type AssetLoaderOptions = {
+    mock?: boolean;
+};
+export declare class AssetLoader extends Group {
+    private interpreter;
+    private options;
+    private manager;
+    private textureLoader;
+    private gltfLoader;
+    private _whenReady;
+    private readonly pendingFinalizers;
+    constructor(interpreter: Interpreter, options?: AssetLoaderOptions);
+    updateMatrixWorld(force?: boolean): void;
+    private handleLoadTexture;
+    private handleLoadModel;
+    whenReady(): Promise<void>;
+    dispose(): void;
+}
+//# sourceMappingURL=loader.d.ts.map

package/dist/assets/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/assets/loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAA6D,MAAM,OAAO,CAAA;AAExF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAM/C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAED,qBAAa,WAAY,SAAQ,KAAK;IAOxB,OAAO,CAAC,WAAW;IAAe,OAAO,CAAC,OAAO;IAN7D,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwB;gBAEtC,WAAW,EAAE,WAAW,EAAU,OAAO,GAAE,kBAAuB;IAmCtF,iBAAiB,CAAC,KAAK,CAAC,EAAE,OAAO;YAUnB,iBAAiB;YA8BjB,eAAe;IA6CvB,SAAS;IAIf,OAAO;CAQR"}

package/dist/assets/loader.js

@@ -0,0 +1,113 @@
+import { Group, Texture, TextureLoader, LoadingManager, Object3D, Matrix4 } from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { ChartaError } from '../errors.js';
+import { ObjectFactory } from '../place/index.js';
+import { InstancedMeshGroup } from '../utils/instanced-mesh-group.js';
+import { object, string } from 'zod';
+export class AssetLoader extends Group {
+    interpreter;
+    options;
+    manager;
+    textureLoader;
+    gltfLoader;
+    _whenReady;
+    pendingFinalizers = [];
+    constructor(interpreter, options = {}) {
+        super();
+        this.interpreter = interpreter;
+        this.options = options;
+        this.manager = new LoadingManager();
+        this.textureLoader = new TextureLoader(this.manager);
+        this.gltfLoader = new GLTFLoader(this.manager);
+        const promises = [];
+        // Schemas
+        const basePathSchema = object({ path: string() });
+        const loadTextureSchema = object({ name: string(), path: string() });
+        const loadModelSchema = object({ name: string(), path: string() });
+        // Parse meta row calls
+        const calls = interpreter.getCalls(undefined, {
+            basePath: basePathSchema,
+            loadTexture: loadTextureSchema,
+            loadModel: loadModelSchema,
+        });
+        let basePath;
+        for (const [key, args, , location] of calls) {
+            if (key === 'basePath') {
+                basePath = args.path.length === 0 ? undefined : args.path;
+            }
+            else if (key === 'loadTexture') {
+                promises.push(this.handleLoadTexture(args.name, basePath, args.path, location));
+            }
+            else if (key === 'loadModel') {
+                promises.push(this.handleLoadModel(args.name, basePath, args.path, location));
+            }
+        }
+        this._whenReady = Promise.all(promises).then(() => { });
+    }
+    updateMatrixWorld(force) {
+        if (this.pendingFinalizers.length > 0) {
+            for (const finalize of this.pendingFinalizers) {
+                finalize();
+            }
+            this.pendingFinalizers.length = 0;
+        }
+        super.updateMatrixWorld(force);
+    }
+    async handleLoadTexture(name, basePath, path, location) {
+        if (this.options.mock) {
+            const texture = new Texture();
+            texture.name = name;
+            this.interpreter.setAsset(`${name}BaseColorTexture`, texture);
+            return;
+        }
+        const fullPath = new URL(path, basePath).href;
+        try {
+            const texture = await this.textureLoader.loadAsync(fullPath);
+            texture.name = name;
+            this.interpreter.setAsset(`${name}BaseColorTexture`, texture);
+        }
+        catch (err) {
+            this.interpreter.reportError(new ChartaError(`Failed to load texture "${name}" at "${fullPath}". Is the url correct?`, this.interpreter.getSource(), location));
+        }
+    }
+    async handleLoadModel(name, basePath, path, location) {
+        if (this.options.mock) {
+            const factory = new ObjectFactory(new Object3D(), () => { });
+            this.interpreter.setAsset(`${name}Factory`, factory);
+            return;
+        }
+        const fullPath = new URL(path, basePath).href;
+        try {
+            const gltf = await this.gltfLoader.loadAsync(fullPath);
+            const scene = gltf.scene;
+            scene.traverse((object) => {
+                object.castShadow = true;
+                object.receiveShadow = true;
+            });
+            const matrices = [];
+            const factory = new ObjectFactory(scene, ({ position, rotation, scale }) => {
+                matrices.push(new Matrix4().compose(position, rotation, scale));
+            });
+            this.interpreter.setAsset(`${name}Factory`, factory);
+            this.pendingFinalizers.push(() => {
+                if (matrices.length > 0) {
+                    this.add(new InstancedMeshGroup(scene, matrices.length, matrices));
+                }
+            });
+        }
+        catch (err) {
+            this.interpreter.reportError(new ChartaError(`Failed to load model ${name} at ${fullPath}: ${err instanceof Error ? err.message : String(err)}`, this.interpreter.getSource(), location));
+        }
+    }
+    async whenReady() {
+        return this._whenReady;
+    }
+    dispose() {
+        this.traverse((child) => {
+            if (child instanceof InstancedMeshGroup) {
+                child.dispose();
+            }
+        });
+        this.clear();
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,11 @@
+export type ErrorLocation = {
+    line: number;
+    column: number;
+    lineText?: string;
+};
+export declare class ChartaError extends Error {
+    readonly source: string;
+    readonly loc?: ErrorLocation | undefined;
+    constructor(causeMessage: string, source: string, loc?: ErrorLocation | undefined);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhF,qBAAa,WAAY,SAAQ,KAAK;aAGlB,MAAM,EAAE,MAAM;aACd,GAAG,CAAC,EAAE,aAAa;gBAFnC,YAAY,EAAE,MAAM,EACJ,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,aAAa,YAAA;CAqBtC"}

package/dist/errors.js

@@ -0,0 +1,27 @@
+export class ChartaError extends Error {
+    source;
+    loc;
+    constructor(causeMessage, source, loc) {
+        let message;
+        if (loc == null) {
+            message = causeMessage;
+        }
+        else {
+            const normalized = source.replace(/\r\n?/g, "\n");
+            const lines = normalized.split("\n");
+            const lineText = loc.lineText ?? lines[loc.line - 1] ?? "";
+            const prefix = `${loc.line} | `;
+            const caret = " ".repeat(prefix.length + loc.column - 1) + "^";
+            message = [
+                causeMessage,
+                `at line ${loc.line}, column ${loc.column}`,
+                `${prefix}${lineText}`,
+                caret,
+            ].join("\n");
+        }
+        super(message);
+        this.source = source;
+        this.loc = loc;
+        this.name = "ChartaError";
+    }
+}

package/dist/grammar.d.ts

@@ -0,0 +1,29 @@
+interface NearleyToken {
+    value: any;
+    [key: string]: any;
+}
+interface NearleyLexer {
+    reset: (chunk: string, info: any) => void;
+    next: () => NearleyToken | undefined;
+    save: () => any;
+    formatError: (token: never) => string;
+    has: (tokenType: string) => boolean;
+}
+interface NearleyRule {
+    name: string;
+    symbols: NearleySymbol[];
+    postprocess?: (d: any[], loc?: number, reject?: {}) => any;
+}
+type NearleySymbol = string | {
+    literal: any;
+} | {
+    test: (token: any) => boolean;
+};
+interface Grammar {
+    Lexer: NearleyLexer | undefined;
+    ParserRules: NearleyRule[];
+    ParserStart: string;
+}
+declare const grammar: Grammar;
+export default grammar;
+//# sourceMappingURL=grammar.d.ts.map

package/dist/grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../src/grammar.ts"],"names":[],"mappings":"AAOA,UAAU,YAAY;IACpB,KAAK,EAAE,GAAG,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;IAC1C,IAAI,EAAE,MAAM,YAAY,GAAG,SAAS,CAAC;IACrC,IAAI,EAAE,MAAM,GAAG,CAAC;IAChB,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC;IACtC,GAAG,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CACrC;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,KAAK,GAAG,CAAC;CAC5D;AAED,KAAK,aAAa,GAAG,MAAM,GAAG;IAAE,OAAO,EAAE,GAAG,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAA;CAAE,CAAC;AAEnF,UAAU,OAAO;IACf,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;IAChC,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,QAAA,MAAM,OAAO,EAAE,OAwGd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/grammar.js

@@ -0,0 +1,119 @@
+// @ts-nocheck
+// Generated automatically by nearley, version 2.20.1
+// http://github.com/Hardmath123/nearley
+// Bypasses TS6133. Allow declared but unused functions.
+// @ts-ignore
+function id(d) { return d[0]; }
+;
+;
+;
+;
+const grammar = {
+    Lexer: undefined,
+    ParserRules: [
+        { "name": "File$ebnf$1", "symbols": ["NL"], "postprocess": id },
+        { "name": "File$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "File", "symbols": ["Rows", "File$ebnf$1"], "postprocess": (d) => d[0] },
+        { "name": "NLS$ebnf$1", "symbols": ["NL"] },
+        { "name": "NLS$ebnf$1", "symbols": ["NLS$ebnf$1", "NL"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "NLS", "symbols": ["NLS$ebnf$1"], "postprocess": () => null },
+        { "name": "NL", "symbols": [{ "literal": "\n" }] },
+        { "name": "Rows$ebnf$1", "symbols": [] },
+        { "name": "Rows$ebnf$1$subexpression$1", "symbols": ["NLS", "Row"] },
+        { "name": "Rows$ebnf$1", "symbols": ["Rows$ebnf$1", "Rows$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "Rows", "symbols": ["Row", "Rows$ebnf$1"], "postprocess": ([head, tail]) => [head, ...tail.map(([, row]) => row)] },
+        { "name": "Row$ebnf$1", "symbols": [] },
+        { "name": "Row$ebnf$1", "symbols": ["Row$ebnf$1", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "Row$ebnf$2", "symbols": [] },
+        { "name": "Row$ebnf$2$subexpression$1", "symbols": ["PIPESep", "Cell"] },
+        { "name": "Row$ebnf$2", "symbols": ["Row$ebnf$2", "Row$ebnf$2$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "Row$ebnf$3", "symbols": [] },
+        { "name": "Row$ebnf$3", "symbols": ["Row$ebnf$3", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "Row", "symbols": ["Row$ebnf$1", "Cell", "Row$ebnf$2", "Row$ebnf$3"], "postprocess": (d, loc) => {
+                const head = d[1];
+                const tail = d[2];
+                const row = [head, ...tail.map(([, cell]) => cell)];
+                row.offset = loc;
+                return row;
+            } },
+        { "name": "Cell$ebnf$1", "symbols": ["Calls"], "postprocess": id },
+        { "name": "Cell$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "Cell", "symbols": ["Cell$ebnf$1"], "postprocess": (d) => d[0] || [] },
+        { "name": "Calls$ebnf$1", "symbols": [] },
+        { "name": "Calls$ebnf$1$subexpression$1", "symbols": ["SP", "Call"] },
+        { "name": "Calls$ebnf$1", "symbols": ["Calls$ebnf$1", "Calls$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "Calls", "symbols": ["Call", "Calls$ebnf$1"], "postprocess": ([first, rest]) => [first, ...rest.map(([, c]) => c)] },
+        { "name": "Call", "symbols": ["Ident", "LPAREN", "ArgsBlock", "RPAREN"], "postprocess": (d, loc) => {
+                const args = d[2];
+                return { name: d[0], locationParams: args.pos, keyParams: args.kv, offset: loc };
+            } },
+        { "name": "ArgList$ebnf$1", "symbols": [] },
+        { "name": "ArgList$ebnf$1$subexpression$1", "symbols": ["COMMASEP", "Arg"] },
+        { "name": "ArgList$ebnf$1", "symbols": ["ArgList$ebnf$1", "ArgList$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "ArgList", "symbols": ["Arg", "ArgList$ebnf$1"], "postprocess": (d) => {
+                const items = [d[0], ...d[1].map((x) => x[1])];
+                const pos = [];
+                const kv = [];
+                for (const a of items) {
+                    if (a && a.kind === 'kv')
+                        kv.push([a.key, a.value]);
+                    else
+                        pos.push(a);
+                }
+                return { pos, kv };
+            } },
+        { "name": "ArgsBlock", "symbols": ["_", "ArgList", "_"], "postprocess": (d) => d[1] },
+        { "name": "ArgsBlock", "symbols": ["_"], "postprocess": () => ({ pos: [], kv: [] }) },
+        { "name": "Arg", "symbols": ["Ident", "WSOpt", "EQ", "WSOpt", "Value"], "postprocess": (d) => ({ kind: 'kv', key: d[0], value: d[4] }) },
+        { "name": "Arg", "symbols": ["Value"], "postprocess": (d) => d[0] },
+        { "name": "Value", "symbols": ["UnescapedString"], "postprocess": (d) => d[0] },
+        { "name": "Value", "symbols": ["EscapedString"], "postprocess": (d) => d[0] },
+        { "name": "EscapedString", "symbols": ["QUOTE", "EscapedStringContent", "QUOTE"], "postprocess": (d) => d[1] },
+        { "name": "EscapedStringContent$ebnf$1", "symbols": [/[^"]/] },
+        { "name": "EscapedStringContent$ebnf$1", "symbols": ["EscapedStringContent$ebnf$1", /[^"]/], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "EscapedStringContent", "symbols": ["EscapedStringContent$ebnf$1"], "postprocess": (d) => d[0].join("") },
+        { "name": "QUOTE", "symbols": [{ "literal": "\"" }] },
+        { "name": "UnescapedString$ebnf$1", "symbols": ["UnescapedStringChar"] },
+        { "name": "UnescapedString$ebnf$1", "symbols": ["UnescapedString$ebnf$1", "UnescapedStringChar"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "UnescapedString", "symbols": ["UnescapedString$ebnf$1"], "postprocess": (d) => d[0].join("") },
+        { "name": "UnescapedStringChar", "symbols": [/[^ \t,()=|\n"]/] },
+        { "name": "LPAREN", "symbols": [{ "literal": "(" }] },
+        { "name": "RPAREN", "symbols": [{ "literal": ")" }] },
+        { "name": "PIPE", "symbols": [{ "literal": "|" }] },
+        { "name": "COMMA", "symbols": [{ "literal": "," }] },
+        { "name": "EQ", "symbols": [{ "literal": "=" }] },
+        { "name": "PIPESep$ebnf$1", "symbols": [] },
+        { "name": "PIPESep$ebnf$1", "symbols": ["PIPESep$ebnf$1", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "PIPESep$ebnf$2", "symbols": [] },
+        { "name": "PIPESep$ebnf$2", "symbols": ["PIPESep$ebnf$2", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "PIPESep", "symbols": ["PIPESep$ebnf$1", "PIPE", "PIPESep$ebnf$2"] },
+        { "name": "COMMASEP$ebnf$1", "symbols": [] },
+        { "name": "COMMASEP$ebnf$1", "symbols": ["COMMASEP$ebnf$1", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "COMMASEP$ebnf$2", "symbols": [] },
+        { "name": "COMMASEP$ebnf$2", "symbols": ["COMMASEP$ebnf$2", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "COMMASEP", "symbols": ["COMMASEP$ebnf$1", "COMMA", "COMMASEP$ebnf$2"] },
+        { "name": "Ident$ebnf$1", "symbols": [] },
+        { "name": "Ident$ebnf$1", "symbols": ["Ident$ebnf$1", "IdentRest"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "Ident", "symbols": ["IdentStart", "Ident$ebnf$1"], "postprocess": ([start, rest]) => start + rest.join("") },
+        { "name": "IdentStart", "symbols": [/[a-z_\/]/] },
+        { "name": "IdentRest", "symbols": [/[a-z0-9A-Z_\/-]/] },
+        { "name": "SP$ebnf$1", "symbols": ["WS"] },
+        { "name": "SP$ebnf$1", "symbols": ["SP$ebnf$1", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "SP", "symbols": ["SP$ebnf$1"], "postprocess": () => null },
+        { "name": "WSOpt$ebnf$1", "symbols": [] },
+        { "name": "WSOpt$ebnf$1", "symbols": ["WSOpt$ebnf$1", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "WSOpt", "symbols": ["WSOpt$ebnf$1"], "postprocess": () => null },
+        { "name": "_$ebnf$1", "symbols": [] },
+        { "name": "_$ebnf$1$subexpression$1", "symbols": ["_unit"] },
+        { "name": "_$ebnf$1", "symbols": ["_$ebnf$1", "_$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "_", "symbols": ["_$ebnf$1"], "postprocess": () => null },
+        { "name": "__$ebnf$1", "symbols": ["WS"] },
+        { "name": "__$ebnf$1", "symbols": ["__$ebnf$1", "WS"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "__", "symbols": ["__$ebnf$1"], "postprocess": () => null },
+        { "name": "_unit", "symbols": ["WS"] },
+        { "name": "WS", "symbols": [/[ \t]/] },
+        { "name": "notnl", "symbols": [/[^\n]/] }
+    ],
+    ParserStart: "File",
+};
+export default grammar;

package/dist/grass/index.d.ts

@@ -0,0 +1,25 @@
+import { InstancedMesh, Material } from "three";
+import { Interpreter } from "../interpreter.js";
+import { type GrassMaterialOptions } from "./material.js";
+export type GrassOptions = GrassMaterialOptions & {
+    bladeSegments?: number;
+    /**
+     * Fade width in meters (preferred). If set, overrides edgeFadeFraction and makes
+     * the fade invariant to cell size. Default: 0.5 (meters) when not using edgeFadeFraction.
+     */
+    edgeFadeMeters?: number;
+    /**
+     * Minimum size scale (applied to both height and width) at the edge.
+     * Range: 0..1. Default: 0.25.
+     */
+    minSizeScale?: number;
+    /**
+     * Strength (0..1) of variation per meter.
+     * Default: 0.8.
+     */
+    variationStrength?: number;
+};
+export declare class GrassMesh extends InstancedMesh {
+    constructor(interpreter: Interpreter, material?: Material, opts?: GrassOptions);
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/grass/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,aAAa,EACb,QAAQ,EAMT,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAY9E,MAAM,MAAM,YAAY,GAAG,oBAAoB,GAAG;IAChD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,qBAAa,SAAU,SAAQ,aAAa;gBAExC,WAAW,EAAE,WAAW,EACxB,QAAQ,GAAE,QAAkC,EAC5C,IAAI,GAAE,YAAiB;CAoO1B"}

package/dist/grass/index.js

@@ -0,0 +1,177 @@
+import { Color, DoubleSide, InstancedMesh, Matrix4, MeshPhongMaterial, PlaneGeometry, Quaternion, Vector3, } from "three";
+import { coerce, object, string } from "zod";
+import { buildGrassMaterial } from "./material.js";
+import { TilesGeometry } from "../tiles/geometry.js";
+const grassSchema = object({
+    color: string().optional(),
+    height: coerce.number().optional(),
+    density: coerce.number().optional(),
+});
+const UpVector = new Vector3(0, 1, 0);
+const colorHelper = new Color();
+export class GrassMesh extends InstancedMesh {
+    constructor(interpreter, material = new MeshPhongMaterial(), opts = {}) {
+        material.side = DoubleSide;
+        const rows = interpreter.getRows();
+        const cols = interpreter.getCols();
+        const cellSize = interpreter.getCellSize();
+        const perCell = new Array(rows)
+            .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++) {
+                const grassParsed = interpreter
+                    .getCalls([z, x], { grass: grassSchema })
+                    .at(-1)?.[1];
+                if (!grassParsed)
+                    continue;
+                const height = grassParsed.height ?? 0.5;
+                const density = Math.max(1, Math.floor(grassParsed.density ?? 100));
+                const subN = Math.ceil(Math.sqrt(density) * cellSize);
+                const width = 0.1;
+                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] = {
+                    subN,
+                    jitterAmp,
+                    height,
+                    width,
+                    topStackIndex,
+                    color: grassParsed.color ?? 0x6c763d,
+                };
+                maxBlades += subN * subN;
+            }
+        }
+        // Compute neighbor flags
+        function hasGrassCell(z, x) {
+            return (!(z < 0 || x < 0 || z >= rows || x >= cols) && perCell[z][x] != null);
+        }
+        for (let z = 0; z < rows; z++) {
+            for (let x = 0; x < cols; x++) {
+                const cell = perCell[z][x];
+                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),
+                };
+            }
+        }
+        const baseSegments = Math.max(1, Math.floor(opts.bladeSegments ?? 3));
+        const geometry = new PlaneGeometry(1, 1, 1, baseSegments);
+        geometry.translate(0, 0.5, 0); // base at y=0
+        super(geometry, material, maxBlades);
+        buildGrassMaterial(this.material, opts);
+        const minSizeScale = Math.min(Math.max(opts.minSizeScale ?? 0.25, 0), 1);
+        const fadeWidthMeters = opts.edgeFadeMeters ?? 1.5;
+        const variationStrength = Math.min(Math.max(opts.variationStrength ?? 0.5, 0), 1);
+        const invFadeScale = fadeWidthMeters > 0 ? 1 / fadeWidthMeters : 0;
+        const invFade = (d) => fadeWidthMeters <= 0 ? 1 : Math.min(Math.max(d * invFadeScale, 0), 1);
+        let instanceIndex = 0;
+        const tmpPos = new Vector3();
+        const mat = new Matrix4();
+        const quat = new Quaternion();
+        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];
+                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;
+                for (let gz = 0; gz < subN; gz++) {
+                    for (let gx = 0; gx < subN; gx++) {
+                        // Optimization: Check stochastic rejection early using simplified fade check
+                        // Normalized coordinates [0,1]
+                        const u = (gx + 0.5) / subN;
+                        const v = (gz + 0.5) / subN;
+                        // Distances to edges
+                        const west = u * cellSize;
+                        const east = (1 - u) * cellSize;
+                        const north = v * cellSize;
+                        const south = (1 - v) * cellSize;
+                        let f = 1;
+                        // Only compute relevant distances based on neighbors
+                        if (nb.left)
+                            f = Math.min(f, invFade(west));
+                        if (nb.right)
+                            f = Math.min(f, invFade(east));
+                        if (nb.top)
+                            f = Math.min(f, invFade(north));
+                        if (nb.bottom)
+                            f = Math.min(f, invFade(south));
+                        if (f < 1) {
+                            // Corner checks if edges didn't already clamp it to 0
+                            // (Only strictly needed if corner is missing but edges are present? 
+                            //  Actually, if left is missing, west is small. 
+                            //  If left is present, west doesn't matter for 'left' check.
+                            //  Corner check is for when top AND left are present, but topLeft is missing.)
+                            if (nb.topLeft)
+                                f = Math.min(f, invFade(Math.hypot(west, north)));
+                            if (nb.topRight)
+                                f = Math.min(f, invFade(Math.hypot(east, north)));
+                            if (nb.bottomRight)
+                                f = Math.min(f, invFade(Math.hypot(east, south)));
+                            if (nb.bottomLeft)
+                                f = Math.min(f, invFade(Math.hypot(west, south)));
+                        }
+                        // Stochastic acceptance
+                        // Using Math.random() is fast and provides white noise distribution (no patterns)
+                        if (Math.random() >= f)
+                            continue;
+                        // --- Instance is accepted ---
+                        // Position
+                        const ox = -cellSize * 0.5 + (gx + 0.5) * step;
+                        const oz = -cellSize * 0.5 + (gz + 0.5) * step;
+                        const jx = (Math.random() * 2 - 1) * jitterAmp;
+                        const jz = (Math.random() * 2 - 1) * jitterAmp;
+                        const px = cx + ox + jx;
+                        const pz = cz + oz + jz;
+                        let baseY = 0;
+                        if (tilesGeometry) {
+                            baseY = tilesGeometry.getHeight(x, z, topStackIndex, px - cx, pz - cz);
+                        }
+                        tmpPos.set(px, baseY, pz);
+                        // Scale
+                        const sizeScale = minSizeScale + (1 - minSizeScale) * f;
+                        // Random variation (-1 to 1)
+                        const sizeVar = Math.random() * 2 - 1;
+                        const heightJitter = 1 + sizeVar * variationStrength;
+                        const widthJitter = 1 + sizeVar * (0.5 * variationStrength);
+                        scale.set(width * sizeScale * widthJitter, height * sizeScale * heightJitter, 1);
+                        // Rotation
+                        quat.setFromAxisAngle(UpVector, (Math.random() - 0.5) * Math.PI * 2.0);
+                        mat.compose(tmpPos, quat, scale);
+                        this.setMatrixAt(instanceIndex, mat);
+                        // Color
+                        const colorVar = Math.random() * 2 - 1;
+                        const colorScale = Math.max(0.7, Math.min(1.4, 1 + colorVar * 0.5 * variationStrength));
+                        // 10x boost kept from original logic
+                        this.setColorAt(instanceIndex, colorHelper.set(cell.color).multiplyScalar(colorScale * 10));
+                        instanceIndex++;
+                    }
+                }
+            }
+        }
+        // Update count to match actual generated blades
+        this.count = instanceIndex;
+        this.instanceMatrix.needsUpdate = true;
+        if (this.instanceColor)
+            this.instanceColor.needsUpdate = true;
+    }
+}

package/dist/grass/material.d.ts

@@ -0,0 +1,10 @@
+import { Material } from "three";
+export type GrassMaterialOptions = {
+    windStrength?: number;
+    windSpatialFreq?: number;
+    windTemporalFreq?: number;
+    baseCurveStrength?: number;
+    windCurveInfluence?: number;
+};
+export declare function buildGrassMaterial(material: Material, opts?: GrassMaterialOptions): void;
+//# sourceMappingURL=material.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"material.d.ts","sourceRoot":"","sources":["../../src/grass/material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,QAAQ,EAClB,IAAI,GAAE,oBAAyB,GAC9B,IAAI,CAiGN"}

package/dist/grass/material.js

@@ -0,0 +1,80 @@
+export function buildGrassMaterial(material, opts = {}) {
+    const windStrength = (opts.windStrength ?? 1.5).toFixed(6);
+    const windFreqX = (opts.windSpatialFreq ?? 1.5).toFixed(6);
+    const windFreqT = (opts.windTemporalFreq ?? 1.5).toFixed(6);
+    const baseCurveStrength = (opts.baseCurveStrength ?? 0.15).toFixed(6);
+    const windCurveInfluence = (opts.windCurveInfluence ?? 1).toFixed(6);
+    material.onBeforeCompile = (shader) => {
+        shader.uniforms.uTime = { value: 0 };
+        shader.vertexShader = shader.vertexShader
+            .replace("#include <common>", `#include <common>
+         varying float vH;         // height along blade [0..1]
+         uniform float uTime;
+         
+         // Simple hash and noise helpers
+         float hash(vec2 p){ return fract(sin(dot(p, vec2(127.1,311.7))) * 43758.5453123); }
+         float noise(vec2 p){
+           vec2 i = floor(p); vec2 f = fract(p);
+           float a = hash(i);
+           float b = hash(i + vec2(1.0, 0.0));
+           float c = hash(i + vec2(0.0, 1.0));
+           float d = hash(i + vec2(1.0, 1.0));
+           vec2 u = f*f*(3.0-2.0*f);
+           return mix(a, b, u.x) + (c - a)*u.y*(1.0 - u.x) + (d - b)*u.x*u.y;
+         }
+        `)
+            .replace("#include <defaultnormal_vertex>", `// Rotate object-space normal by the same forward bend (includes wind) before normalMatrix
+         float vHn = clamp( uv.y, 0.0, 1.0 );
+         vec3 iPos_n = (instanceMatrix)[3].xyz;
+         float n_n = noise(vec2(iPos_n.x * ${windFreqX}, iPos_n.z * ${windFreqX}) + vec2(uTime*${windFreqT}, 0.0));
+         float wind_n = ${windStrength} * (n_n - 0.5);
+         float baseCurve_n = vHn * ${baseCurveStrength};
+         float curve_n = baseCurve_n * (1.0 + ${windCurveInfluence} * wind_n);
+         float cn = cos(curve_n);
+         float sn = sin(curve_n);
+         objectNormal.yz = mat2(cn, -sn, sn, cn) * objectNormal.yz;
+
+         // Apply lateral sway to local object normal as well (independent of wind)
+         float lateral = (uv.x - 0.5);
+         float sway = 0.08 * lateral;
+         float cny = cos(sway);
+         float sny = sin(sway);
+         objectNormal.xz = mat2(cny, -sny, sny, cny) * objectNormal.xz;
+
+         #include <defaultnormal_vertex>
+        `)
+            .replace("#include <begin_vertex>", `#include <begin_vertex>
+         // Height fraction from UVs (plane geometry provides 0..1 along v)
+         vH = clamp( uv.y, 0.0, 1.0 );
+
+         // Non-linear taper: 1 at base, 0 at tip
+         float widthScale = 1.0 - vH * vH;
+         transformed.x *= widthScale;
+
+         // Wind: sample noise from instance world position (translation from instanceMatrix)
+         vec3 iPos = (instanceMatrix)[3].xyz;
+         float n = noise(vec2(iPos.x * ${windFreqX}, iPos.z * ${windFreqX}) + vec2(uTime*${windFreqT}, 0.0));
+         float wind = ${windStrength} * (n - 0.5);
+
+         // Always apply a gentle forward curve that increases toward the tip,
+         // and modulate it slightly by wind
+         float baseCurve = vH * ${baseCurveStrength};
+         float curve = baseCurve * (1.0 + ${windCurveInfluence} * wind);
+         float cw = cos(curve);
+         float sw = sin(curve);
+         transformed.yz = mat2(cw, -sw, sw, cw) * transformed.yz;
+        `);
+        // Fragment modifications: declare varyings and blend color towards tip color by height
+        shader.fragmentShader = shader.fragmentShader
+            .replace("#include <common>", `#include <common>
+         varying float vH;
+        `)
+            .replace("#include <color_fragment>", `#include <color_fragment>
+         // Darken blade downward (vH 0 -> darker, vH 1 -> base color)
+         diffuseColor.rgb *= mix(0.2, 1.0, vH);
+        `);
+        // Animate time
+        const old = shader.uniforms;
+        material.__grassTick = (t) => { old.uTime.value = t; };
+    };
+}