@drawcall/charta 0.1.7 → 0.1.9

package/dist/assets/loader.d.ts

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

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

@@ -1 +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"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/assets/loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,cAAc,EAAqB,MAAM,EAAW,MAAM,OAAO,CAAA;AAEzG,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAU/C,qBAAa,WAAY,SAAQ,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC;IAIlB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAH3D,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,UAAU,CAAY;gBAElB,OAAO,CAAC,EAAE,cAAc,EAAmB,IAAI,GAAE,OAAe;IAM5E,IAAI,CACF,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAC5B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAC/B,IAAI;YAuBO,iBAAiB;YA8BjB,eAAe;CAuC9B"}

package/dist/assets/loader.js

@@ -1,79 +1,67 @@
-import { Group, Texture, TextureLoader, LoadingManager, Object3D, Matrix4 } from 'three';
+import { Texture, TextureLoader, Object3D, Loader, Vector3 } 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;
+import { measureObject, PrefabBatchBuilder } from '../place/index.js';
+// Schemas
+const basePathSchema = object({ path: string() });
+const loadTextureSchema = object({ name: string(), path: string() });
+const loadModelSchema = object({ name: string(), path: string() });
+export class AssetLoader extends Loader {
+    mock;
     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
+    constructor(manager, mock = false) {
+        super(manager);
+        this.mock = mock;
+        this.textureLoader = new TextureLoader(manager);
+        this.gltfLoader = new GLTFLoader(manager);
+    }
+    load(interpreter, onLoad, onProgress, onError) {
         const calls = interpreter.getCalls(undefined, {
             basePath: basePathSchema,
             loadTexture: loadTextureSchema,
             loadModel: loadModelSchema,
         });
+        const promises = [];
         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));
+                promises.push(this.handleLoadTexture(interpreter, 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();
+                promises.push(this.handleLoadModel(interpreter, args.name, basePath, args.path, location));
             }
-            this.pendingFinalizers.length = 0;
         }
-        super.updateMatrixWorld(force);
+        Promise.all(promises)
+            .then(() => onLoad())
+            .catch((reason) => onError?.(reason));
     }
-    async handleLoadTexture(name, basePath, path, location) {
-        if (this.options.mock) {
+    async handleLoadTexture(interpreter, name, basePath, path, location) {
+        if (this.mock) {
             const texture = new Texture();
             texture.name = name;
-            this.interpreter.setAsset(`${name}BaseColorTexture`, texture);
+            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);
+            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));
+            interpreter.reportError(new ChartaError(`Failed to load texture "${name}" at "${fullPath}". Is the url correct?`, 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);
+    async handleLoadModel(interpreter, name, basePath, path, location) {
+        if (this.mock) {
+            const batchBuilder = new PrefabBatchBuilder(new Vector3(), () => new Object3D());
+            interpreter.setAsset(`${name}Prefab`, batchBuilder);
             return;
         }
         const fullPath = new URL(path, basePath).href;
@@ -84,30 +72,11 @@ export class AssetLoader extends Group {
                 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));
-                }
-            });
+            const batchBuilder = new PrefabBatchBuilder(measureObject(scene), (matrices) => new InstancedMeshGroup(scene, matrices.length, matrices));
+            interpreter.setAsset(`${name}Prefab`, batchBuilder);
         }
         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));
+            interpreter.reportError(new ChartaError(`Failed to load model ${name} at ${fullPath}: ${err instanceof Error ? err.message : String(err)}`, interpreter.getSource(), location));
         }
     }
-    async whenReady() {
-        return this._whenReady;
-    }
-    dispose() {
-        this.traverse((child) => {
-            if (child instanceof InstancedMeshGroup) {
-                child.dispose();
-            }
-        });
-        this.clear();
-    }
 }

package/dist/place/index.d.ts

@@ -1,4 +1,4 @@
-import { Group, Material, Object3D, Quaternion, Vector3 } from 'three';
+import { Group, Material, Matrix4, Object3D, Quaternion, Vector3 } from 'three';
 import { Interpreter } from '../interpreter.js';
 export type MeasureFunction = (target: Vector3) => void;
 export type InstantiateFunction = (args: {
@@ -13,25 +13,18 @@ export type InstantiateFunction = (args: {
     };
     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 function measureObject(object: Object3D): Vector3;
+export declare class PrefabBatchBuilder {
+    readonly prefabSize: Vector3;
+    private readonly buildFromMatrices;
+    private matrices;
+    constructor(prefabSize: Vector3, buildFromMatrices: (matrices: Array<Matrix4>) => Object3D);
+    add(matrix: Matrix4): this;
+    build(): Object3D;
 }
 export declare class PlaceGroup extends Group {
+    private batchBuilders;
     constructor(interpreter: Interpreter, _materialFallback?: Material);
+    dispose(): void;
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/place/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,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;AAKV,wBAAgB,aAAa,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO,CAOvD;AAED,qBAAa,kBAAkB;aAIX,UAAU,EAAE,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAJpC,OAAO,CAAC,QAAQ,CAAqB;gBAGnB,UAAU,EAAE,OAAO,EAClB,iBAAiB,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,QAAQ;IAG5E,GAAG,CAAC,MAAM,EAAE,OAAO;IAKZ,KAAK,IAAI,QAAQ;CAKzB;AAED,qBAAa,UAAW,SAAQ,KAAK;IACnC,OAAO,CAAC,aAAa,CAAgC;gBAEzC,WAAW,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,QAAQ;IAqNlE,OAAO;CAOR"}

package/dist/place/index.js

@@ -1,4 +1,4 @@
-import { Group, Matrix4, Object3D, Quaternion, Vector3, Box3 } from 'three';
+import { Group, Matrix4, 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';
@@ -30,28 +30,35 @@ const placeSchema = object({
     sizeZ: coerce.number().optional(),
 });
 const boxHelper = new Box3();
-export class ObjectFactory {
-    _measure;
-    _instantiate;
-    constructor(_measure, _instantiate) {
-        this._measure = _measure;
-        this._instantiate = _instantiate;
+const matrixHelper = new Matrix4();
+export function measureObject(object) {
+    const parent = object.parent;
+    object.parent = null;
+    const target = new Vector3();
+    boxHelper.setFromObject(object).getSize(target);
+    object.parent = parent;
+    return target;
+}
+export class PrefabBatchBuilder {
+    prefabSize;
+    buildFromMatrices;
+    matrices = [];
+    constructor(prefabSize, buildFromMatrices) {
+        this.prefabSize = prefabSize;
+        this.buildFromMatrices = buildFromMatrices;
     }
-    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);
+    add(matrix) {
+        this.matrices.push(matrix.clone());
+        return this;
     }
-    instantiate(args) {
-        this._instantiate(args);
+    build() {
+        const batch = this.buildFromMatrices(this.matrices);
+        this.matrices = [];
+        return batch;
     }
 }
 export class PlaceGroup extends Group {
+    batchBuilders = new Set();
     constructor(interpreter, _materialFallback) {
         super();
         const rows = interpreter.getRows();
@@ -120,12 +127,13 @@ export class PlaceGroup extends Group {
                 // 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)
+                    const prefabName = `${parsed.model}Prefab`;
+                    const batchBuilder = interpreter.getAsset(PrefabBatchBuilder, prefabName, loc);
+                    if (!batchBuilder)
                         continue;
+                    this.batchBuilders.add(batchBuilder);
                     const usualSize = new Vector3();
-                    factory.measure(usualSize);
+                    usualSize.copy(batchBuilder.prefabSize);
                     const base = hashStringToUint32(parsed.model);
                     const seed = hashNumbersToUint32(base, z, x);
                     const rng = createRng(seed);
@@ -168,14 +176,7 @@ export class PlaceGroup extends Group {
                             : 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,
-                        });
+                        batchBuilder.add(matrixHelper.compose(pos, quat, scl));
                     }
                 }
                 // place: exact in-cell placement
@@ -193,24 +194,28 @@ export class PlaceGroup extends Group {
                         fixedY: parsed.bottomY,
                         layerIndex,
                     });
-                    const factoryName = `${parsed.model}Factory`;
-                    const factory = interpreter.getAsset(ObjectFactory, factoryName, loc);
-                    if (!factory)
+                    const prefabName = `${parsed.model}Prefab`;
+                    const batchBuilder = interpreter.getAsset(PrefabBatchBuilder, prefabName, loc);
+                    if (!batchBuilder)
                         continue;
+                    this.batchBuilders.add(batchBuilder);
                     const usualSize = new Vector3();
-                    factory.measure(usualSize);
+                    usualSize.copy(batchBuilder.prefabSize);
                     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,
-                    });
+                    batchBuilder.add(matrixHelper.compose(pos, quat, scl));
                 }
             }
         }
+        for (const batchBuilder of this.batchBuilders) {
+            this.add(batchBuilder.build());
+        }
+    }
+    dispose() {
+        for (const child of this.children) {
+            if ('dispose' in child && typeof child.dispose === 'function') {
+                child.dispose();
+            }
+        }
     }
 }

package/package.json

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