@drawcall/charta 0.0.0

package/dist/pillars/material.js

@@ -0,0 +1,43 @@
+export function buildPillarMeshMaterial(material, textureArray) {
+    material.onBeforeCompile = (shader) => {
+        shader.uniforms.uTextureArray = { value: textureArray };
+        shader.vertexShader = shader.vertexShader.replace("#include <common>", `#include <common>
+      attribute float instanceTextureId;
+      varying float vTextureId;
+      varying vec2 vUvMeters;`);
+        shader.vertexShader = shader.vertexShader.replace("#include <uv_vertex>", `
+      #include <uv_vertex>
+      vTextureId = instanceTextureId;
+      // Derive per-instance scale (robust even if rotation were introduced)
+      vec3 col0 = vec3(instanceMatrix[0][0], instanceMatrix[0][1], instanceMatrix[0][2]);
+      vec3 col1 = vec3(instanceMatrix[1][0], instanceMatrix[1][1], instanceMatrix[1][2]);
+      vec3 col2 = vec3(instanceMatrix[2][0], instanceMatrix[2][1], instanceMatrix[2][2]);
+      float sx = length(col0);
+      float sy = length(col1);
+      float sz = length(col2);
+      float bottomY = instanceMatrix[3][1];
+      vec3 n = normal;
+      vec3 p = position;
+      // Map UVs in meters depending on face
+      if (abs(n.y) > 0.5) {
+        // top/bottom caps: tile by footprint in meters
+        vUvMeters = vec2( (p.x + 0.5) * sx, (p.z + 0.5) * sz );
+      } else if (abs(n.x) > 0.5) {
+        // faces perpendicular to X: use Z for U, world Y for V
+        vUvMeters = vec2( (p.z + 0.5) * sz, bottomY + p.y * sy );
+      } else {
+        // faces perpendicular to Z: use X for U, world Y for V
+        vUvMeters = vec2( (p.x + 0.5) * sx, bottomY + p.y * sy );
+      }
+      `);
+        shader.fragmentShader =
+            `
+      varying float vTextureId;
+      uniform sampler2DArray uTextureArray;
+      varying vec2 vUvMeters;
+    ` + shader.fragmentShader;
+        shader.fragmentShader = shader.fragmentShader.replace("#include <map_fragment>", `#include <map_fragment>
+      vec4 texelColor = texture(uTextureArray, vec3(vUvMeters, vTextureId));
+      diffuseColor *= texelColor;`);
+    };
+}

package/dist/place/index.d.ts

@@ -0,0 +1,37 @@
+import { Group, Material, Object3D, Quaternion, Vector3 } from 'three';
+import { Interpreter } from '../interpreter.js';
+export type MeasureFunction = (target: Vector3) => void;
+export type InstantiateFunction = (args: {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    interpreter: Interpreter;
+    cell: {
+        row: number;
+        col: number;
+        center: [number, number];
+    };
+    name: string;
+}) => void;
+export declare class ObjectFactory {
+    private readonly _measure;
+    private readonly _instantiate;
+    constructor(_measure: MeasureFunction | Object3D, _instantiate: InstantiateFunction);
+    measure(target: Vector3): void;
+    instantiate(args: {
+        position: Vector3;
+        rotation: Quaternion;
+        scale: Vector3;
+        interpreter: Interpreter;
+        cell: {
+            row: number;
+            col: number;
+            center: [number, number];
+        };
+        name: string;
+    }): void;
+}
+export declare class PlaceGroup extends Group {
+    constructor(interpreter: Interpreter, _materialFallback?: Material);
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/place/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAW,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAQ,MAAM,OAAO,CAAA;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAmC/C,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;AAEvD,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE;IACvC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,UAAU,CAAA;IACpB,KAAK,EAAE,OAAO,CAAA;IACd,WAAW,EAAE,WAAW,CAAA;IACxB,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;IAC5D,IAAI,EAAE,MAAM,CAAA;CACb,KAAK,IAAI,CAAA;AAIV,qBAAa,aAAa;IAEtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADZ,QAAQ,EAAE,eAAe,GAAG,QAAQ,EACpC,YAAY,EAAE,mBAAmB;IAGpD,OAAO,CAAC,MAAM,EAAE,OAAO;IAWvB,WAAW,CAAC,IAAI,EAAE;QAChB,QAAQ,EAAE,OAAO,CAAA;QACjB,QAAQ,EAAE,UAAU,CAAA;QACpB,KAAK,EAAE,OAAO,CAAA;QACd,WAAW,EAAE,WAAW,CAAA;QACxB,IAAI,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;SAAE,CAAA;QAC5D,IAAI,EAAE,MAAM,CAAA;KACb;CAGF;AAED,qBAAa,UAAW,SAAQ,KAAK;gBACvB,WAAW,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,QAAQ;CA0NnE"}

package/dist/place/index.js

@@ -0,0 +1,216 @@
+import { Group, Matrix4, Object3D, Quaternion, Vector3, Box3 } from 'three';
+import { TilesGeometry } from '../tiles/geometry.js';
+import { coerce, object, string, enum as zodEnum } from 'zod';
+import { createRng, hashNumbersToUint32, hashStringToUint32 } from '../utils/random.js';
+import { degToRad } from 'three/src/math/MathUtils.js';
+const alignEnum = zodEnum(['up', 'normal']);
+const scatterSchema = object({
+    model: string(),
+    density: coerce.number().optional(),
+    bottomY: coerce.number().optional(),
+    yaw: coerce.number().optional(),
+    yawMin: coerce.number().optional(),
+    yawMax: coerce.number().optional(),
+    align: alignEnum.optional(),
+    sizeX: coerce.number().optional(),
+    minSizeX: coerce.number().optional(),
+    maxSizeX: coerce.number().optional(),
+    sizeZ: coerce.number().optional(),
+    minSizeZ: coerce.number().optional(),
+    maxSizeZ: coerce.number().optional(),
+});
+const placeSchema = object({
+    model: string(),
+    offsetX: coerce.number().optional(),
+    offsetZ: coerce.number().optional(),
+    bottomY: coerce.number().optional(),
+    yaw: coerce.number().optional(),
+    align: alignEnum.optional(),
+    sizeX: coerce.number().optional(),
+    sizeZ: coerce.number().optional(),
+});
+const boxHelper = new Box3();
+export class ObjectFactory {
+    _measure;
+    _instantiate;
+    constructor(_measure, _instantiate) {
+        this._measure = _measure;
+        this._instantiate = _instantiate;
+    }
+    measure(target) {
+        if (this._measure instanceof Object3D) {
+            const parent = this._measure.parent;
+            this._measure.parent = null;
+            boxHelper.setFromObject(this._measure).getSize(target);
+            this._measure.parent = parent;
+            return;
+        }
+        this._measure(target);
+    }
+    instantiate(args) {
+        this._instantiate(args);
+    }
+}
+export class PlaceGroup extends Group {
+    constructor(interpreter, _materialFallback) {
+        super();
+        const rows = interpreter.getRows();
+        const cols = interpreter.getCols();
+        const cellSize = interpreter.getCellSize();
+        const tilesGeometry = interpreter.getAsset(TilesGeometry, 'tilesGeometry');
+        if (!tilesGeometry) {
+            return;
+        }
+        const computeTransform = (px, pz, cell, opts) => {
+            const normal = new Vector3();
+            const offsetX = px - cell.center[0];
+            const offsetZ = pz - cell.center[1];
+            let py = 0;
+            if (opts.useFixedY) {
+                py = opts.fixedY;
+            }
+            else {
+                py = tilesGeometry.getHeight(cell.col, cell.row, opts.layerIndex, offsetX, offsetZ, normal);
+            }
+            const pos = new Vector3(px, py, pz);
+            const quat = new Quaternion();
+            if (opts.alignMode === 'normal' && !opts.useFixedY) {
+                const qAlign = new Quaternion().setFromUnitVectors(new Vector3(0, 1, 0), normal);
+                const qYaw = new Quaternion().setFromAxisAngle(normal, degToRad(opts.yaw));
+                quat.multiplyQuaternions(qYaw, qAlign);
+            }
+            else {
+                quat.setFromAxisAngle(new Vector3(0, 1, 0), degToRad(opts.yaw));
+            }
+            // Scale is handled by the factory via size
+            const scl = new Vector3(1, 1, 1);
+            const matrix = new Matrix4().compose(pos, quat, scl);
+            return { pos, quat, scl, matrix };
+        };
+        const computeScale = (usualSize, sizeX, sizeZ) => {
+            if (sizeX === undefined && sizeZ === undefined)
+                return new Vector3(1, 1, 1);
+            // Avoid division by zero
+            const safeUsualX = Math.max(usualSize.x, 0.001);
+            const safeUsualZ = Math.max(usualSize.z, 0.001);
+            let sFactorX;
+            let sFactorZ;
+            if (sizeX !== undefined) {
+                sFactorX = sizeX / safeUsualX;
+            }
+            if (sizeZ !== undefined) {
+                sFactorZ = sizeZ / safeUsualZ;
+            }
+            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], {
+                    scatter: scatterSchema,
+                });
+                const placeEntries = interpreter.getCalls([z, x], {
+                    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 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 factoryName = `${parsed.model}Factory`;
+                    const factory = interpreter.getAsset(ObjectFactory, factoryName, loc);
+                    if (!factory)
+                        continue;
+                    const usualSize = new Vector3();
+                    factory.measure(usualSize);
+                    const base = hashStringToUint32(parsed.model);
+                    const seed = hashNumbersToUint32(base, z, x);
+                    const rng = createRng(seed);
+                    // area-based density: items per m^2
+                    // expected = density * area; stochastic rounding using seeded rng
+                    const densityPerSqm = Math.max(0, parsed.density ?? 1 / (usualSize.x * usualSize.z * 2));
+                    const area = cellSize * cellSize;
+                    const expected = densityPerSqm * area;
+                    const baseCount = Math.floor(expected);
+                    const fractional = expected - baseCount;
+                    const count = baseCount + (rng() < fractional ? 1 : 0);
+                    if (count <= 0)
+                        continue;
+                    const useFixedY = parsed.bottomY != null;
+                    const yawMin = parsed.yawMin ?? 0;
+                    const yawMax = parsed.yawMax ?? (parsed.yaw != null ? parsed.yaw : Math.PI * 2);
+                    const minSizeX = parsed.minSizeX ?? parsed.sizeX ?? usualSize.x * 0.8;
+                    const maxSizeX = parsed.maxSizeX ?? parsed.sizeX ?? usualSize.x * 1.2;
+                    const minSizeZ = parsed.minSizeZ ?? parsed.sizeZ ?? usualSize.z * 0.8;
+                    const maxSizeZ = parsed.maxSizeZ ?? parsed.sizeZ ?? usualSize.z * 1.2;
+                    const alignMode = (parsed.align ?? 'up').toLowerCase();
+                    for (let i = 0; i < count; i++) {
+                        const ox = (rng() * 2 - 1) * half;
+                        const oz = (rng() * 2 - 1) * half;
+                        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] }, {
+                            alignMode,
+                            yaw,
+                            useFixedY: useFixedY,
+                            fixedY: parsed.bottomY,
+                            layerIndex,
+                        });
+                        const sX = minSizeX !== undefined && maxSizeX !== undefined
+                            ? minSizeX + (maxSizeX - minSizeX) * rng()
+                            : minSizeX ?? maxSizeX;
+                        const sZ = minSizeZ !== undefined && maxSizeZ !== undefined
+                            ? minSizeZ + (maxSizeZ - minSizeZ) * rng()
+                            : minSizeZ ?? maxSizeZ;
+                        const scale = computeScale(usualSize, sX, sZ);
+                        scl.multiply(scale);
+                        factory.instantiate({
+                            position: pos,
+                            rotation: quat,
+                            scale: scl,
+                            interpreter,
+                            cell: { row: z, col: x, center: [cx, cz] },
+                            name: parsed.model,
+                        });
+                    }
+                }
+                // 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 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] }, {
+                        alignMode,
+                        yaw,
+                        useFixedY: parsed.bottomY != null,
+                        fixedY: parsed.bottomY,
+                        layerIndex,
+                    });
+                    const factoryName = `${parsed.model}Factory`;
+                    const factory = interpreter.getAsset(ObjectFactory, factoryName, loc);
+                    if (!factory)
+                        continue;
+                    const usualSize = new Vector3();
+                    factory.measure(usualSize);
+                    const scale = computeScale(usualSize, parsed.sizeX, parsed.sizeZ);
+                    scl.multiply(scale);
+                    factory.instantiate({
+                        position: pos,
+                        rotation: quat,
+                        scale: scl,
+                        interpreter,
+                        cell: { row: z, col: x, center: [cx, cz] },
+                        name: parsed.model,
+                    });
+                }
+            }
+        }
+    }
+}

package/dist/tiles/geometry.d.ts

@@ -0,0 +1,46 @@
+import { BufferGeometry, Vector3 } from 'three';
+export type Tile = {
+    type: string;
+    y: number;
+    textureId: number;
+    cellIndexX: number;
+    cellIndexZ: number;
+};
+export type WallData = {
+    topY: number;
+    bottomY: number;
+};
+export declare class TilesGeometry extends BufferGeometry {
+    private readonly tiles;
+    private readonly walls;
+    readonly mapSizeX: number;
+    readonly mapSizeZ: number;
+    readonly cellSizeX: number;
+    readonly cellSizeZ: number;
+    private readonly vertices;
+    private readonly positions;
+    private readonly uvs;
+    private readonly textureStrengths;
+    private idCounter;
+    private readonly xConnections;
+    private readonly zConnections;
+    constructor(tiles: Array<Array<Array<Tile>>>, walls: Array<Array<{
+        top: Array<WallData>;
+        right: Array<WallData>;
+        bottom: Array<WallData>;
+        left: Array<WallData>;
+    }>>, mapSizeX: number, mapSizeZ: number);
+    /**
+     * @param xIndex tile grid x index
+     * @param zIndex tile grid z index
+     * @param stackIndex index in the tile stack
+     * @param offsetX world unit offset from tile center X
+     * @param offsetZ world unit offset from tile center Z
+     * @param normalTarget optional target vector that will receive the interpolated face normal at the queried point
+     */
+    getHeight(xIndex: number, zIndex: number, stackIndex: number, offsetX: number, offsetZ: number, normalTarget?: Vector3): number;
+    private addVertex;
+    private getVertices;
+    private getConnectionVertexId;
+}
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +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"}