@3driseai/3drise-core 1.0.9 → 1.0.11

package/dist/utils/LayoutCreator.js

@@ -0,0 +1,521 @@
+import { modeGroupOf } from "./surfaceUtils.js";
+export class LayoutCreator {
+    /**
+     * Creates a scattered gallery layout with concentric circles
+     * Center image + rings of images around it, with side images rotated inward
+     */
+    static scattered(count, spacing = 3.5) {
+        const numImages = count;
+        const frames = [];
+        const actualCount = numImages;
+        if (actualCount === 0)
+            return frames;
+        // First image at center
+        frames.push({
+            position: [0, 0, 0],
+            rotation: [0, 0, 0],
+        });
+        let imageIndex = 1;
+        let ringNumber = 1;
+        // Distribute remaining images across rings
+        while (imageIndex < actualCount) {
+            const radius = ringNumber * spacing;
+            // Each ring can hold more images as radius increases
+            const imagesInRing = Math.min(Math.ceil(6 + ringNumber * 2), // 8, 10, 12, 14... images per ring
+            actualCount - imageIndex);
+            for (let i = 0; i < imagesInRing && imageIndex < actualCount; i++) {
+                const angle = (i / imagesInRing) * Math.PI * 2;
+                const x = Math.cos(angle) * radius;
+                const z = Math.sin(angle) * radius;
+                frames.push({
+                    position: [x, 0, z],
+                    rotation: [0, 0, 0], // All images face forward for now
+                });
+                imageIndex++;
+            }
+            ringNumber++;
+        }
+        return frames;
+    }
+    /**
+     * Creates a grid/tile layout with frames arranged in rows and columns
+     */
+    static tiles(count, columns = 3, spacing = 2.5) {
+        const frames = [];
+        const totalImages = count;
+        const rows = Math.ceil(totalImages / columns);
+        // Calculate centering offset to position gallery center at [0, 0, 0]
+        const totalWidth = (columns - 1) * spacing;
+        const totalHeight = (rows - 1) * spacing;
+        const offsetX = -totalWidth / 2;
+        const offsetY = -totalHeight / 2;
+        for (let i = 0; i < totalImages; i++) {
+            const row = Math.floor(i / columns);
+            const col = i % columns;
+            frames.push({
+                position: [
+                    offsetX + col * spacing,
+                    offsetY + row * spacing,
+                    0, // Centered at origin
+                ],
+                rotation: [0, 0, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a horizontal row layout
+     */
+    static horizontal(count, spacing = 2.5, startX = 0) {
+        const frames = [];
+        const totalImages = count;
+        // Calculate centering offset to position gallery center at [0, 0, 0]
+        const totalWidth = (totalImages - 1) * spacing;
+        const offsetX = startX - totalWidth / 2;
+        for (let i = 0; i < totalImages; i++) {
+            frames.push({
+                position: [offsetX + i * spacing, 0, 0],
+                rotation: [0, 0, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a vertical column layout
+     */
+    static vertical(count, spacing = 2.0, startY = 0) {
+        const frames = [];
+        const totalImages = count;
+        // Calculate centering offset to position gallery center at [0, 0, 0]
+        const totalHeight = (totalImages - 1) * spacing;
+        const offsetY = startY - totalHeight / 2;
+        for (let i = 0; i < totalImages; i++) {
+            frames.push({
+                position: [0, offsetY + i * spacing, 0],
+                rotation: [0, 0, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a circular layout with images arranged in a ring
+     */
+    static circular(count, radius = 5) {
+        const frames = [];
+        const totalImages = count;
+        for (let i = 0; i < totalImages; i++) {
+            const angle = (i / totalImages) * Math.PI * 2;
+            const x = Math.cos(angle) * radius;
+            const z = Math.sin(angle) * radius;
+            frames.push({
+                position: [x, 0, z],
+                rotation: [0, -angle, 0], // Face inward
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a spiral layout ascending or expanding outward
+     */
+    static spiral(count, radius = 5, rotations = 2, heightIncrement = 0.5) {
+        const frames = [];
+        const totalImages = count;
+        for (let i = 0; i < totalImages; i++) {
+            const progress = i / totalImages;
+            const angle = progress * rotations * Math.PI * 2;
+            const currentRadius = radius * (1 - progress * 0.3); // Spiral inward slightly
+            const x = Math.cos(angle) * currentRadius;
+            const z = Math.sin(angle) * currentRadius;
+            const y = progress * totalImages * heightIncrement - (totalImages * heightIncrement) / 2;
+            frames.push({
+                position: [x, y, z],
+                rotation: [0, -angle, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates an arc/curved layout
+     */
+    static arc(count, radius = 5, arcAngle = Math.PI) {
+        const frames = [];
+        const totalImages = count;
+        for (let i = 0; i < totalImages; i++) {
+            const progress = i / (totalImages - 1 || 1);
+            const angle = -arcAngle / 2 + progress * arcAngle;
+            const x = Math.sin(angle) * radius;
+            const z = Math.cos(angle) * radius;
+            frames.push({
+                position: [x, 0, z],
+                rotation: [0, -angle, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a pyramid stack layout
+     */
+    static pyramid(count, layers = 3, spacing = 2.5) {
+        const frames = [];
+        let imageIndex = 0;
+        for (let layer = layers; layer > 0; layer--) {
+            const itemsInLayer = layer;
+            const layerY = (layers - layer) * spacing - (layers * spacing) / 2;
+            const layerWidth = (itemsInLayer - 1) * spacing;
+            const offsetX = -layerWidth / 2;
+            for (let i = 0; i < itemsInLayer && imageIndex < count; i++) {
+                frames.push({
+                    position: [offsetX + i * spacing, layerY, 0],
+                    rotation: [0, 0, 0],
+                });
+                imageIndex++;
+            }
+        }
+        return frames;
+    }
+    /**
+     * Creates a helix (DNA-style spiral)
+     */
+    static helix(count, radius = 3, rotations = 3, heightIncrement = 0.4) {
+        const frames = [];
+        const totalImages = count;
+        for (let i = 0; i < totalImages; i++) {
+            const progress = i / totalImages;
+            const angle = progress * rotations * Math.PI * 2;
+            const x = Math.cos(angle) * radius;
+            const z = Math.sin(angle) * radius;
+            const y = progress * totalImages * heightIncrement - (totalImages * heightIncrement) / 2;
+            frames.push({
+                position: [x, y, z],
+                rotation: [0, -angle - Math.PI / 2, 0], // Tangent to helix
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a 3D box layout with images on all 6 faces
+     */
+    static box(count, size = 5) {
+        const frames = [];
+        const imagesPerFace = Math.ceil(count / 6);
+        let imageIndex = 0;
+        // Define the 6 faces: Front, Back, Right, Left, Top, Bottom
+        const faceConfigs = [
+            { name: 'Front', basePos: [0, 0, size], baseRot: [0, 0, 0] },
+            { name: 'Back', basePos: [0, 0, -size], baseRot: [0, Math.PI, 0] },
+            { name: 'Right', basePos: [size, 0, 0], baseRot: [0, Math.PI / 2, 0] },
+            { name: 'Left', basePos: [-size, 0, 0], baseRot: [0, -Math.PI / 2, 0] },
+            { name: 'Top', basePos: [0, size, 0], baseRot: [-Math.PI / 2, 0, 0] },
+            { name: 'Bottom', basePos: [0, -size, 0], baseRot: [Math.PI / 2, 0, 0] }
+        ];
+        for (let faceIndex = 0; faceIndex < 6 && imageIndex < count; faceIndex++) {
+            const config = faceConfigs[faceIndex];
+            const itemsOnFace = Math.min(imagesPerFace, count - imageIndex);
+            const cols = Math.ceil(Math.sqrt(itemsOnFace));
+            const rows = Math.ceil(itemsOnFace / cols);
+            const spacing = (size * 1.8) / Math.max(cols, rows);
+            for (let i = 0; i < itemsOnFace; i++) {
+                const row = Math.floor(i / cols);
+                const col = i % cols;
+                const offsetX = (col - (cols - 1) / 2) * spacing;
+                const offsetY = (row - (rows - 1) / 2) * spacing;
+                // Calculate position based on face orientation
+                let position;
+                if (faceIndex === 0)
+                    position = [offsetX, offsetY, size]; // Front
+                else if (faceIndex === 1)
+                    position = [-offsetX, offsetY, -size]; // Back (mirror X)
+                else if (faceIndex === 2)
+                    position = [size, offsetY, -offsetX]; // Right (X fixed, offset in -Z)
+                else if (faceIndex === 3)
+                    position = [-size, offsetY, offsetX]; // Left (X fixed, offset in +Z)
+                else if (faceIndex === 4)
+                    position = [offsetX, size, -offsetY]; // Top (Y fixed, offset in -Z)
+                else
+                    position = [offsetX, -size, offsetY]; // Bottom (Y fixed, offset in +Z)
+                frames.push({
+                    position,
+                    rotation: config.baseRot,
+                });
+                imageIndex++;
+            }
+        }
+        return frames;
+    }
+    /**
+     * Creates a sphere layout with images distributed evenly on a sphere surface
+     * Uses Fibonacci sphere algorithm for even distribution
+     */
+    static sphere(count, radius = 5) {
+        const frames = [];
+        const totalImages = count;
+        const goldenRatio = (1 + Math.sqrt(5)) / 2;
+        const angleIncrement = Math.PI * 2 * goldenRatio;
+        for (let i = 0; i < totalImages; i++) {
+            // Fibonacci sphere distribution
+            const t = i / totalImages;
+            const inclination = Math.acos(1 - 2 * t); // 0 to PI (theta - angle from north pole)
+            const azimuth = angleIncrement * i; // phi - angle around equator
+            // Convert spherical to Cartesian coordinates
+            const x = radius * Math.sin(inclination) * Math.cos(azimuth);
+            const y = radius * Math.cos(inclination);
+            const z = radius * Math.sin(inclination) * Math.sin(azimuth);
+            frames.push({
+                position: [x, y, z],
+                rotation: [0, 0, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a fan/radial layout
+     */
+    static fan(count, radius = 5, arcAngle = Math.PI * 1.5) {
+        const frames = [];
+        const totalImages = count;
+        for (let i = 0; i < totalImages; i++) {
+            const progress = i / (totalImages - 1 || 1);
+            const angle = -arcAngle / 2 + progress * arcAngle;
+            const x = Math.sin(angle) * radius;
+            const z = Math.cos(angle) * radius;
+            frames.push({
+                position: [x, 0, z],
+                rotation: [0, -angle, 0], // All face center
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a wave pattern layout
+     */
+    static wave(count, amplitude = 2, frequency = 2, spacing = 1.5) {
+        const frames = [];
+        const totalImages = count;
+        const totalWidth = (totalImages - 1) * spacing;
+        const offsetX = -totalWidth / 2;
+        for (let i = 0; i < totalImages; i++) {
+            const x = offsetX + i * spacing;
+            const progress = i / totalImages;
+            const y = Math.sin(progress * frequency * Math.PI * 2) * amplitude;
+            frames.push({
+                position: [x, y, 0],
+                rotation: [0, 0, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a tunnel/perspective layout
+     */
+    static tunnel(count, depth = 20, scaleFactor = 0.8) {
+        const frames = [];
+        const totalImages = count;
+        for (let i = 0; i < totalImages; i++) {
+            const progress = i / totalImages;
+            const z = -progress * depth;
+            const scale = Math.pow(scaleFactor, i);
+            frames.push({
+                position: [0, 0, z],
+                rotation: [0, 0, 0],
+                scale: [scale, scale, scale],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a tunnel-pyramid layout combining depth perspective with pyramid stacking
+     * Starts with 1 frame at front, expands as it recedes. All at y=0
+     */
+    static tunnelPyramid(count, depth = 20, layers = 6, spacing = 2.5) {
+        const frames = [];
+        let imageIndex = 0;
+        let currentLayer = 1;
+        // Continue adding layers until all images are placed
+        while (imageIndex < count) {
+            const itemsInLayer = currentLayer;
+            const layerProgress = (currentLayer - 1) / (layers - 1 || 1);
+            const z = -layerProgress * depth;
+            const layerWidth = (itemsInLayer - 1) * spacing;
+            const offsetX = -layerWidth / 2;
+            for (let i = 0; i < itemsInLayer && imageIndex < count; i++) {
+                frames.push({
+                    position: [offsetX + i * spacing, 0, z], // Y always 0
+                    rotation: [0, 0, 0],
+                });
+                imageIndex++;
+            }
+            currentLayer++;
+        }
+        return frames;
+    }
+    /**
+     * Creates a tunnel-wave layout combining depth perspective with wave pattern
+     * Wave pattern in X axis, all at y=0, receding in Z
+     */
+    static tunnelWave(count, depth = 20, amplitude = 2, frequency = 2, spacing = 1.5) {
+        const frames = [];
+        const totalImages = count;
+        for (let i = 0; i < totalImages; i++) {
+            const progress = i / totalImages;
+            const x = Math.sin(progress * frequency * Math.PI * 2) * amplitude;
+            const z = -progress * depth;
+            frames.push({
+                position: [x, 0, z], // Y always 0, wave in X
+                rotation: [0, 0, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Creates a random/organic layout
+     */
+    static random(count, bounds = 8, seed = 1) {
+        const frames = [];
+        const totalImages = count;
+        const rand = seededRandom(seed);
+        for (let i = 0; i < totalImages; i++) {
+            const x = (rand() - 0.5) * bounds * 2;
+            const y = (rand() - 0.5) * bounds;
+            const z = (rand() - 0.5) * bounds * 2;
+            const rotY = rand() * Math.PI * 2;
+            frames.push({
+                position: [x, y, z],
+                rotation: [0, rotY, 0],
+            });
+        }
+        return frames;
+    }
+    /**
+     * Slots for `count` copies in the given layout. Reads only the fields the layout uses
+     * (see GALLERY_LAYOUT_CONFIGS); anything missing falls back to that layout's default.
+     */
+    static generate(count, settings) {
+        const n = Math.max(0, Math.floor(count || 0));
+        switch (settings.layout) {
+            case 'scattered':
+                return this.scattered(n, settings.spacing || 3.5);
+            case 'tiles':
+                return this.tiles(n, settings.columns || 3, settings.spacing || 2.5);
+            case 'horizontal':
+                return this.horizontal(n, settings.spacing || 2.5, settings.startX || 0);
+            case 'vertical':
+                return this.vertical(n, settings.spacing || 2.0, settings.startY || 0);
+            case 'circular':
+                return this.circular(n, settings.radius || 5);
+            case 'spiral':
+                return this.spiral(n, settings.radius || 5, settings.rotations || 2, settings.heightIncrement || 0.5);
+            case 'arc':
+                return this.arc(n, settings.radius || 5, settings.arcAngle || Math.PI);
+            case 'pyramid':
+                return this.pyramid(n, settings.layers || 3, settings.spacing || 2.5);
+            case 'helix':
+                return this.helix(n, settings.radius || 3, settings.rotations || 3, settings.heightIncrement || 0.4);
+            case 'box':
+                return this.box(n, settings.size || 5);
+            case 'sphere':
+                return this.sphere(n, settings.radius || 5);
+            case 'fan':
+                return this.fan(n, settings.radius || 5, settings.arcAngle || Math.PI * 1.5);
+            case 'wave':
+                return this.wave(n, settings.amplitude || 2, settings.frequency || 2, settings.spacing || 1.5);
+            case 'tunnel':
+                return this.tunnel(n, settings.depth || 20, settings.scaleFactor || 0.8);
+            case 'tunnelPyramid':
+                return this.tunnelPyramid(n, settings.depth || 20, settings.layers || 3, settings.spacing || 2.5);
+            case 'tunnelWave':
+                return this.tunnelWave(n, settings.depth || 20, settings.amplitude || 2, settings.frequency || 2, settings.spacing || 1.5);
+            case 'random':
+                return this.random(n, settings.bounds || 8, settings.seed ?? 1);
+            default:
+                return this.scattered(n);
+        }
+    }
+}
+export const generateLayoutSlots = (count, settings) => LayoutCreator.generate(count, settings);
+// =============================================================================
+// Object layout (meshSettings.layout) — repeat a scene object in a gallery layout
+// =============================================================================
+/** Object types whose renderer output ObjectNode can repeat across layout slots. */
+export const LAYOUT_CAPABLE_TYPES = new Set(['mesh', 'model', 'effect', 'light']);
+export const DEFAULT_OBJECT_LAYOUT = {
+    enabled: false,
+    layout: 'circular',
+    count: 6,
+    seed: 1,
+    columns: 3,
+    spacing: 3.5,
+    startX: 0,
+    startY: 0,
+    radius: 5,
+    size: 5,
+    rotations: 2,
+    heightIncrement: 0.5,
+    arcAngle: Math.PI,
+    amplitude: 2,
+    frequency: 2,
+    layers: 3,
+    depth: 20,
+    scaleFactor: 0.8,
+    bounds: 8,
+};
+/**
+ * Saved objects predate this field. Absent means no layout at all — never the default —
+ * and a partial block is merged over the defaults so an added knob fills in.
+ */
+export const normalizeObjectLayout = (layout) => {
+    if (!layout || typeof layout !== 'object')
+        return null;
+    return { ...DEFAULT_OBJECT_LAYOUT, ...layout };
+};
+/**
+ * Per-type ceilings on layout copies. Every copy is a full render of the object, so these
+ * track what each copy costs:
+ * - light: each one adds per-fragment cost to every lit material, and changing the light
+ *   count recompiles every material (three.js keys programs on light counts).
+ * - effect: each copy is a whole particle / shader effect.
+ * - mesh in a points mode: each copy resamples its points (volumeFill raycasts in render).
+ * - model: geometry is shared with the cache master, but every part of every copy is its
+ *   own draw call with its own material clone.
+ */
+export const LAYOUT_COUNT_LIMITS = {
+    mesh: 100,
+    meshPoints: 12,
+    model: 30,
+    effect: 24,
+    light: 8,
+};
+/** Light kinds a layout makes sense for: N directional copies are one brighter light, and
+ *  an ambient light has no position. */
+export const LAYOUT_LIGHT_KINDS = new Set(['point', 'spot']);
+/** Whether this object can be repeated, and how many times. One answer for the viewer and the panel. */
+export const getObjectLayoutSupport = (obj) => {
+    switch (obj.type) {
+        case 'mesh':
+            return modeGroupOf(obj.modeConfig?.mode) === 'points'
+                ? { allowed: true, maxCount: LAYOUT_COUNT_LIMITS.meshPoints }
+                : { allowed: true, maxCount: LAYOUT_COUNT_LIMITS.mesh };
+        case 'model':
+            return { allowed: true, maxCount: LAYOUT_COUNT_LIMITS.model };
+        case 'effect':
+            return { allowed: true, maxCount: LAYOUT_COUNT_LIMITS.effect };
+        case 'light': {
+            const kind = obj.config?.type;
+            return kind && LAYOUT_LIGHT_KINDS.has(kind)
+                ? { allowed: true, maxCount: LAYOUT_COUNT_LIMITS.light }
+                : { allowed: false, maxCount: 0, reason: 'Layouts work with point and spot lights only.' };
+        }
+        default:
+            return { allowed: false, maxCount: 0, reason: 'This object type cannot be repeated in a layout.' };
+    }
+};
+/** mulberry32 — deterministic, so a random layout keeps its shape across re-renders. */
+function seededRandom(seed) {
+    let a = (Math.floor(seed) || 1) >>> 0;
+    return () => {
+        a = (a + 0x6D2B79F5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"galleriesUtils.d.ts","sourceRoot":"","sources":["../../src/utils/galleriesUtils.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtH,eAAO,MAAM,gBAAgB,EAAE,MAAM,EAqBpC,CAAC;AACF,eAAO,MAAM,2BAA2B,GAAI,KAAK,MAAM,KAAG,MAAM,EAM/D,CAAC;AAIF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,aAAa,KAAG,qBAuBhE,CAAC;AACF,eAAO,MAAM,2BAA2B,GAAI,iBAAiB,qBAAqB,EAAE,cAAc,OAAO,CAAC,qBAAqB,CAAC,KAAG;IAC3H,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,cAAc,EAAE,qBAAqB,CAAC;CA8B7C,CAAC;AAIF,eAAO,MAAM,mBAAmB,EAAE,aAgEjC,CAAC"}
+{"version":3,"file":"galleriesUtils.d.ts","sourceRoot":"","sources":["../../src/utils/galleriesUtils.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKtH,eAAO,MAAM,gBAAgB,EAAE,MAAM,EAqBpC,CAAC;AACF,eAAO,MAAM,2BAA2B,GAAI,KAAK,MAAM,KAAG,MAAM,EAM/D,CAAC;AAIF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,aAAa,KAAG,qBAwBhE,CAAC;AACF,eAAO,MAAM,2BAA2B,GAAI,iBAAiB,qBAAqB,EAAE,cAAc,OAAO,CAAC,qBAAqB,CAAC,KAAG;IAC3H,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,cAAc,EAAE,qBAAqB,CAAC;CA8B7C,CAAC;AAIF,eAAO,MAAM,mBAAmB,EAAE,aAgEjC,CAAC"}

package/dist/utils/galleriesUtils.js

@@ -48,6 +48,7 @@ export const getInitialLayoutSettings = (layout) => {
         startX: 0,
         startY: 0,
         radius: 5,
+        size: 5,
         rotations: 2,
         heightIncrement: 0.5,
         arcAngle: Math.PI,
@@ -63,7 +64,6 @@ export const getInitialLayoutSettings = (layout) => {
     return getLayoutSettings(layout, galleryState);
 };
 export const updateCurrentLayoutSettings = (currentSettings, newSettings) => {
-    console.log('Updating layout settings for gallery:', currentSettings);
     const galleryState = {
         geometryType: newSettings?.geometryType ?? currentSettings.geometryType,
         columns: newSettings?.columns ?? currentSettings.columns ?? 3,
@@ -73,6 +73,8 @@ export const updateCurrentLayoutSettings = (currentSettings, newSettings) => {
         startX: newSettings?.startX ?? currentSettings.startX ?? 0,
         startY: newSettings?.startY ?? currentSettings.startY ?? 0,
         radius: newSettings?.radius ?? currentSettings.radius ?? 5,
+        size: newSettings?.size ?? currentSettings.size ?? 5,
+        seed: newSettings?.seed ?? currentSettings.seed ?? 1,
         rotations: newSettings?.rotations ?? currentSettings.rotations ?? 2,
         heightIncrement: newSettings?.heightIncrement ?? currentSettings.heightIncrement ?? 0.5,
         arcAngle: newSettings?.arcAngle ?? currentSettings.arcAngle ?? Math.PI,
@@ -89,7 +91,6 @@ export const updateCurrentLayoutSettings = (currentSettings, newSettings) => {
     const frames = GalleryCreator.generateGallery(currentSettings.imageUrls && currentSettings.imageUrls.length > 0
         ? currentSettings.imageUrls
         : createNumberOfDefaultImages(galleryState.numImages ?? 20), galleryState);
-    const layoutSettings = getLayoutSettings(currentSettings.layout, galleryState);
     return { frames, layoutSettings: galleryState };
 };
 // =============================================================================

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

@@ -1 +1 @@
-{"version":3,"file":"handleTransformEffects.d.ts","sourceRoot":"","sources":["../../src/utils/handleTransformEffects.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAKtC,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE,QAAQ,CAAC;IACjB,YAAY,EAAE,GAAG,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACzB;AAMD,eAAO,MAAM,uBAAuB,QAAQ,CAAC;AAS7C;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAmBxN;AAID;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,yBAAyB,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAoDrJ;AAID;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE;IACtJ,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;CAC/B,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAqBjC"}
+{"version":3,"file":"handleTransformEffects.d.ts","sourceRoot":"","sources":["../../src/utils/handleTransformEffects.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAKtC,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE,QAAQ,CAAC;IACjB,YAAY,EAAE,GAAG,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACzB;AAMD,eAAO,MAAM,uBAAuB,QAAQ,CAAC;AAS7C;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAmBxN;AAID;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,yBAAyB,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAsDrJ;AAID;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE;IACtJ,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;CAC/B,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAqBjC"}

package/dist/utils/handleTransformEffects.js

@@ -83,9 +83,11 @@ export function handleTransformAnimations(ctx, animations, currentTime, hovered)
         const targetsToAnimate = [];
         if (objectIds && objectIds.length > 0) {
             // Animate specific children by name
-            objectIds.forEach((name) => {
-                const child = object.getObjectByName(name);
-                if (child) {
+            // Every match, not getObjectByName's first: a model repeated by
+            // meshSettings.layout has the same part name once per copy.
+            const names = new Set(objectIds);
+            object.traverse((child) => {
+                if (child.name && names.has(child.name)) {
                     targetsToAnimate.push(child);
                 }
             });

package/dist/utils/index.d.ts

@@ -4,10 +4,12 @@ export * from './frameAnimations';
 export * from './particleAnimations';
 export * from './galleriesUtils';
 export * from './GalleryCreator';
+export * from './LayoutCreator';
 export * from './GalleryLayouts';
 export * from './gridUtils';
 export * from './idUtils';
 export * from './loadingManager';
+export * from './modelCache';
 export * from './materialApplicationUtils';
 export * from './materialUtils';
 export * from './meshUtils';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}

package/dist/utils/index.js

@@ -4,10 +4,12 @@ export * from './frameAnimations.js';
 export * from './particleAnimations.js';
 export * from './galleriesUtils.js';
 export * from './GalleryCreator.js';
+export * from './LayoutCreator.js';
 export * from './GalleryLayouts.js';
 export * from './gridUtils.js';
 export * from './idUtils.js';
 export * from './loadingManager.js';
+export * from './modelCache.js';
 export * from './materialApplicationUtils.js';
 export * from './materialUtils.js';
 export * from './meshUtils.js';