minerender 2.1.0-alpha.123 → 2.1.0-alpha.125

package/dist/bundle.js

@@ -88859,11 +88859,14 @@ ${key}` : key;
           });
         }
         static fillMissingTextureKeys(textures, target) {
-          for (let faceName of CUBE_FACES) {
-            let v5 = textures[faceName];
-            if (v5 && v5.startsWith("#")) {
-              target[faceName] = target[v5.substr(1)];
+          for (const key in textures) {
+            let name2 = key;
+            const seen = /* @__PURE__ */ new Set();
+            while (textures[name2]?.startsWith("#") && !seen.has(name2)) {
+              seen.add(name2);
+              name2 = textures[name2].substr(1);
             }
+            if (name2 !== key) target[key] = target[name2];
           }
           return target;
         }
@@ -90268,13 +90271,14 @@ ${key}` : key;
         }
         /**
          * Plays a clip from {@link Entities.getAnimations}, replacing all active clips.
-         * Offsets apply to the baked pose in the clip's layer (`main` by default), including repeated draws of that layer.
+         * Offsets apply to the baked pose in the clip's layer (`main` by default) and its repeated draws.
+         * A `main` clip also poses every selected layer without a clip of its own.
          * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
          */
         playAnimation(animation, options) {
           this.playAnimations([animation], options);
         }
-        /** Plays one clip per selected geometry layer, with a shared clock and no blending between clips. */
+        /** Plays clips with a shared clock and no blending. Selected layers without their own clip follow `main`. */
         playAnimations(animations, options) {
           const targets = /* @__PURE__ */ new Set();
           const selections = animations.map((animation) => {
@@ -90285,6 +90289,8 @@ ${key}` : key;
             if (!names.length) throw new Error(`Entity ${this.entity.id} has no selected animation layer "${layer}"`);
             return { animation, names };
           });
+          const main = selections.find(({ animation }) => (animation.layer ?? "main") === "main");
+          if (main) main.names.push(...Object.keys(this.entityLayers).filter((name2) => !targets.has(name2.split("#")[0])));
           this.createMeshes();
           this.stopAnimation();
           for (const { animation, names } of selections) {
@@ -90344,24 +90350,26 @@ ${key}` : key;
         createMeshes(force = false) {
           if (this.meshesCreated && !force) return;
           const modelRoot = new Object3D();
+          let transformNode = modelRoot;
           const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
           if (transform) {
-            for (const op of transform) {
-              const matrix = new Matrix4();
-              if ("scale" in op) matrix.makeScale(...op.scale);
-              else if ("translate" in op) matrix.makeTranslation(...op.translate);
-              else matrix.makeRotationFromEuler(new Euler(...op.rotate, "ZYX"));
-              modelRoot.matrix.multiply(matrix);
-            }
-            modelRoot.matrixWorldNeedsUpdate = true;
-            modelRoot.matrixAutoUpdate = false;
+            for (const [index, op] of transform.entries()) {
+              if (index > 0) {
+                const child = new Object3D();
+                transformNode.add(child);
+                transformNode = child;
+              }
+              if ("scale" in op) transformNode.scale.set(...op.scale);
+              else if ("translate" in op) transformNode.position.set(...op.translate);
+              else transformNode.rotation.set(...op.rotate, "ZYX");
+            }
           } else if (this.options.flip ?? true) {
             modelRoot.scale.set(-1, -1, 1);
           }
           this.add(modelRoot);
           Object.entries(this.entityLayers).forEach(([name2, layer], index) => {
             const group = this.createGroup(`layer:${name2}`);
-            modelRoot.add(group);
+            transformNode.add(group);
             const inward = !Materials.entityModeCulls(layer.render ?? layer.layer.render);
             this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index, inward, this.options.faces?.[name2]);
           });