@drawcall/charta 0.0.0

package/dist/tiles/material.js

@@ -0,0 +1,88 @@
+/**
+ * Modifies an existing Three.js material to support texture array blending based on textureStrength
+ */
+export function buildTilesMaterial(material, textureArray) {
+    material.onBeforeCompile = (shader) => {
+        // Add uniforms
+        shader.uniforms.uTextureArray = { value: textureArray };
+        // Vertex shader modifications
+        shader.vertexShader = shader.vertexShader
+            .replace("#include <common>", `#include <common>
+        attribute mat4 textureStrength;
+        varying mat4 vTextureStrength;
+        #ifndef USE_MAP
+          varying vec2 vUv;
+        #endif`)
+            .replace("#include <begin_vertex>", `#include <begin_vertex>
+        vTextureStrength = textureStrength;
+        #ifndef USE_MAP
+          vUv = uv;
+        #endif`);
+        // Fragment shader modifications
+        shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>
+        uniform sampler2DArray uTextureArray;
+        varying mat4 vTextureStrength;
+        #ifndef USE_MAP
+          varying vec2 vUv;
+        #endif
+
+        vec2 hash2( vec2 p ) {
+          return fract(sin(vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3))))*43758.5453);
+        }
+
+        float voronoi( in vec2 x ) {
+          vec2 n = floor( x );
+          vec2 f = fract( x );
+          float m = 8.0;
+          for( int j=-1; j<=1; j++ )
+          for( int i=-1; i<=1; i++ ) {
+            vec2 g = vec2( float(i), float(j) );
+            vec2 o = hash2( n + g );
+            vec2 r = g - f + o;
+            float d = dot( r, r );
+            m = min( m, d );
+          }
+          return sqrt(m);
+        }`);
+        // Apply texture blending
+        shader.fragmentShader = shader.fragmentShader.replace("#include <map_fragment>", `#include <map_fragment>
+        vec3 blendedColor = vec3(0.0);
+        
+        // Use prime number scale for noise to avoid grid alignment
+        float noise = voronoi(vUv * 0.6);
+        float mixVal = smoothstep(0.4, 0.6, noise);
+
+        float weightSum = 0.001;
+        
+        // Generate a noise value for mixing layers
+        float layerNoise = voronoi(vUv * 0.5);
+
+        for (int i = 0; i < 4; i++) {
+          for (int j = 0; j < 4; j++) {
+             float baseWeight = vTextureStrength[i][j];
+             
+             // Only process if weight is significant
+             if (baseWeight > 0.001) {
+                 // Modulate weight with noise to create organic transitions between layers
+                 // Using pow to sharpen the transition
+                 float noiseWeight = smoothstep(0.4, 0.6, baseWeight * layerNoise + baseWeight * 0.9);
+                 float w = baseWeight * noiseWeight;
+                 
+                 int layerIndex = i * 4 + j;
+                 
+                 vec3 tex1 = texture(uTextureArray, vec3(vUv, float(layerIndex))).rgb;
+                 vec3 tex2 = texture(uTextureArray, vec3(-vUv + 0.35, float(layerIndex))).rgb;
+                 
+                 vec3 texSample = mix(tex1, tex2, mixVal) * (voronoi(vUv * 1.5 + 12.0) * 0.2 + 0.9);
+                 
+                 blendedColor += texSample * w;
+                 weightSum += w;
+             }
+          }
+        }
+        
+        diffuseColor.rgb = blendedColor / weightSum;`);
+    };
+    material.needsUpdate = true;
+    return material;
+}

package/dist/utils/instanced-mesh-group.d.ts

@@ -0,0 +1,17 @@
+import { Group, InstancedMesh, Matrix4, Object3D } from "three";
+interface InstancedMeshEntry {
+    mesh: InstancedMesh;
+    offsetMatrix: Matrix4;
+}
+export declare class InstancedMeshGroup extends Group {
+    entries: InstancedMeshEntry[];
+    constructor(object: Object3D, count: number, matrices?: Array<Matrix4>);
+    setMatrixAt(index: number, matrix: Matrix4): void;
+    /**
+     * Disposes all internal InstancedMeshes.
+     * Note: Does not dispose geometries or materials as they might be shared.
+     */
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=instanced-mesh-group.d.ts.map

package/dist/utils/instanced-mesh-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanced-mesh-group.d.ts","sourceRoot":"","sources":["../../src/utils/instanced-mesh-group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAQ,QAAQ,EAAS,MAAM,OAAO,CAAC;AAE7E,UAAU,kBAAkB;IAC1B,IAAI,EAAE,aAAa,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,OAAO,EAAE,kBAAkB,EAAE,CAAM;gBAEvB,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;IA6CtE,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO;IAiB1C;;;OAGG;IACH,OAAO;CAOR"}

package/dist/utils/instanced-mesh-group.js

@@ -0,0 +1,59 @@
+import { Group, InstancedMesh, Matrix4 } from "three";
+export class InstancedMeshGroup extends Group {
+    entries = [];
+    constructor(object, count, matrices) {
+        super();
+        // Ensure the source object has its world matrices up to date
+        object.updateMatrixWorld(true);
+        const rootInverse = new Matrix4().copy(object.matrixWorld).invert();
+        object.traverse((child) => {
+            if (child.isMesh) {
+                const mesh = child;
+                // Calculate the offset matrix relative to the root object
+                const offsetMatrix = new Matrix4().multiplyMatrices(rootInverse, mesh.matrixWorld);
+                // Create InstancedMesh with the same geometry and material
+                // We clone the geometry to avoid side effects if the original is modified,
+                // but sharing is also possible. Given we don't modify it, sharing is fine usually.
+                // However, InstancedMesh might modify the geometry (e.g. attribute updates?).
+                // Usually it's safe to share geometry.
+                const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, count);
+                // Copy shadow properties
+                instancedMesh.castShadow = mesh.castShadow;
+                instancedMesh.receiveShadow = mesh.receiveShadow;
+                this.add(instancedMesh);
+                this.entries.push({ mesh: instancedMesh, offsetMatrix });
+            }
+        });
+        if (matrices != null) {
+            for (let i = 0; i < Math.min(count, matrices.length); i++) {
+                this.setMatrixAt(i, matrices[i]);
+            }
+        }
+    }
+    setMatrixAt(index, matrix) {
+        const instanceMatrix = new Matrix4();
+        for (const entry of this.entries) {
+            // Calculate the final matrix for this part:
+            // PartWorld = InstanceRootWorld * PartOffset
+            instanceMatrix.multiplyMatrices(matrix, entry.offsetMatrix);
+            entry.mesh.setMatrixAt(index, instanceMatrix);
+        }
+        // Mark all as needing update
+        for (const entry of this.entries) {
+            if (entry.mesh.instanceMatrix) {
+                entry.mesh.instanceMatrix.needsUpdate = true;
+            }
+        }
+    }
+    /**
+     * Disposes all internal InstancedMeshes.
+     * Note: Does not dispose geometries or materials as they might be shared.
+     */
+    dispose() {
+        for (const entry of this.entries) {
+            entry.mesh.dispose();
+        }
+        this.entries = [];
+        this.clear();
+    }
+}

package/dist/utils/random.d.ts

@@ -0,0 +1,4 @@
+export declare function createRng(seed: string | number): () => number;
+export declare function hashStringToUint32(input: string, seed?: number): number;
+export declare function hashNumbersToUint32(...nums: number[]): number;
+//# sourceMappingURL=random.d.ts.map

package/dist/utils/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src/utils/random.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,MAAM,CAG7D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU,GAAG,MAAM,CAE1E;AAED,wBAAgB,mBAAmB,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAQ7D"}

package/dist/utils/random.js

@@ -0,0 +1,19 @@
+import seedrandom from "seedrandom";
+import MurmurHash3 from "imurmurhash";
+export function createRng(seed) {
+    const rng = seedrandom(String(seed));
+    return () => rng();
+}
+export function hashStringToUint32(input, seed = 0) {
+    return new MurmurHash3(input, seed).result() >>> 0;
+}
+export function hashNumbersToUint32(...nums) {
+    let hasher = new MurmurHash3("", 0);
+    for (let i = 0; i < nums.length; i++) {
+        // Use '|' separator to avoid ambiguities; stringify to be simple and robust
+        if (i > 0)
+            hasher = hasher.hash("|");
+        hasher = hasher.hash(String(nums[i] >>> 0));
+    }
+    return hasher.result() >>> 0;
+}

package/dist/utils/texture.d.ts

@@ -0,0 +1,3 @@
+import { Texture, DataArrayTexture } from "three";
+export declare function buildTextureArrayFromAssets(textures: Texture[]): DataArrayTexture;
+//# sourceMappingURL=texture.d.ts.map

package/dist/utils/texture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture.d.ts","sourceRoot":"","sources":["../../src/utils/texture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,gBAAgB,EAIjB,MAAM,OAAO,CAAC;AAEf,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EAAE,GAClB,gBAAgB,CA6BlB"}

package/dist/utils/texture.js

@@ -0,0 +1,30 @@
+import { DataArrayTexture, LinearMipMapLinearFilter, LinearFilter, RepeatWrapping, } from "three";
+export function buildTextureArrayFromAssets(textures) {
+    const images = textures.map((t) => t.image);
+    if (images.some((image) => image == null)) {
+        return new DataArrayTexture();
+    }
+    const width = images[0].width;
+    const height = images[0].height;
+    const depth = images.length;
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    const data = new Uint8Array(width * height * 4 * depth);
+    for (let i = 0; i < depth; i++) {
+        const img = images[i];
+        ctx.clearRect(0, 0, width, height);
+        ctx.drawImage(img, 0, 0, width, height);
+        const imgData = ctx.getImageData(0, 0, width, height).data;
+        data.set(imgData, i * width * height * 4);
+    }
+    const arrayTex = new DataArrayTexture(data, width, height, depth);
+    arrayTex.needsUpdate = true;
+    arrayTex.minFilter = LinearMipMapLinearFilter;
+    arrayTex.magFilter = LinearFilter;
+    arrayTex.wrapS = RepeatWrapping;
+    arrayTex.wrapT = RepeatWrapping;
+    arrayTex.generateMipmaps = true;
+    return arrayTex;
+}

package/dist/walls/index.d.ts

@@ -0,0 +1,87 @@
+import { Material, Mesh, Vector2Tuple, Vector3Tuple } from 'three';
+import { Interpreter } from '../interpreter.js';
+import { coerce } from 'zod';
+import { TilesGeometry } from '../tiles/geometry.js';
+import { ErrorLocation } from '../errors.js';
+export type WindowData = {
+    offsetX: number;
+    bottomY: number;
+    topY: number;
+    width: number;
+};
+export type WallData = {
+    x: number;
+    z: number;
+    xzSize: Vector2Tuple;
+    rotationY: number;
+    yStart: Vector3Tuple;
+    yEnd: Vector3Tuple;
+    textureId: number;
+    windows: WindowData[];
+};
+export declare const windowSchema: import("zod").ZodObject<{
+    offsetX: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+    bottomY: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+    topY: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+    width: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+}, import("zod/v4/core").$strip>;
+export declare const doorSchema: import("zod").ZodObject<{
+    offsetX: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+    bottomY: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+    topY: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+    height: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+    width: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+}, import("zod/v4/core").$strip>;
+export declare const wallSchema: import("zod").ZodObject<{
+    dir: import("zod").ZodEnum<{
+        top: "top";
+        bottom: "bottom";
+        left: "left";
+        right: "right";
+    }>;
+    texture: import("zod").ZodString;
+    bottomY: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+    topY: import("zod").ZodOptional<coerce.ZodCoercedNumber<unknown>>;
+}, import("zod/v4/core").$strip>;
+export declare const WALL_CONFIG: {
+    readonly top: {
+        readonly zOffset: -0.5;
+        readonly rotation: 0;
+        readonly axis: "z";
+        readonly sampleDir: 1;
+    };
+    readonly bottom: {
+        readonly zOffset: 0.5;
+        readonly rotation: 0;
+        readonly axis: "z";
+        readonly sampleDir: 1;
+    };
+    readonly left: {
+        readonly xOffset: -0.5;
+        readonly rotation: number;
+        readonly axis: "x";
+        readonly sampleDir: -1;
+    };
+    readonly right: {
+        readonly xOffset: 0.5;
+        readonly rotation: number;
+        readonly axis: "x";
+        readonly sampleDir: -1;
+    };
+};
+export declare const WALL_CONNECTION_TOLERANCE_RATIO: number;
+export declare function computeWallVerticalBounds(interpreter: Interpreter, tilesGeometry: TilesGeometry, row: number, col: number, wallIdx: number, parsed: {
+    bottomY?: number;
+    topY?: number;
+    dir: string;
+}, config: (typeof WALL_CONFIG)[keyof typeof WALL_CONFIG], loc: ErrorLocation): {
+    yStart: Vector3Tuple;
+    yEnd: Vector3Tuple;
+    worldWallX: number;
+    worldWallZ: number;
+} | undefined;
+export declare class WallMesh extends Mesh {
+    constructor(interpreter: Interpreter, material?: Material);
+}
+export declare function isLayerConnectedToWall(wallTopY: number, wallBotY: number, y: number, tileSize: number): boolean;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/walls/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAER,IAAI,EAGJ,YAAY,EAEZ,YAAY,EAOb,MAAM,OAAO,CAAA;AAEd,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAyC,MAAM,KAAK,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAGpD,OAAO,EAAe,aAAa,EAAE,MAAM,cAAc,CAAA;AAMzD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,MAAM,EAAE,YAAY,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,YAAY,CAAA;IACpB,IAAI,EAAE,YAAY,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,UAAU,EAAE,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,YAAY;;;;;gCAKvB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;gCAMrB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;gCAKrB,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAed,CAAA;AAEV,eAAO,MAAM,+BAA+B,QAAQ,CAAA;AAEpD,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,MAAM,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACxD,MAAM,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,EACtD,GAAG,EAAE,aAAa;;;;;cAqInB;AAED,qBAAa,QAAS,SAAQ,IAAI;gBACpB,WAAW,EAAE,WAAW,EAAE,QAAQ,GAAE,QAAkC;CA6QnF;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,WAGrG"}