minerender 2.1.0-alpha.26 → 2.1.0-alpha.28

package/dist/bundle.js

@@ -45411,6 +45411,7 @@ return ${compiler2.callType("value", tagType)}
     SchematicParser: () => SchematicParser,
     SkinObject: () => SkinObject,
     SkinPart: () => SkinPart,
+    SkinTextures: () => SkinTextures,
     Skins: () => Skins,
     StructureParser: () => StructureParser,
     TextureAtlas: () => TextureAtlas,
@@ -63612,6 +63613,16 @@ return ${compiler2.callType("value", tagType)}
       }
     }
   };
+  var DataTexture = class extends Texture {
+    constructor(data = null, width = 1, height = 1, format2, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace) {
+      super(null, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy, colorSpace);
+      this.isDataTexture = true;
+      this.image = { data, width, height };
+      this.generateMipmaps = false;
+      this.flipY = false;
+      this.unpackAlignment = 1;
+    }
+  };
   var InstancedBufferAttribute = class extends BufferAttribute {
     constructor(array, itemSize, normalized, meshPerAttribute = 1) {
       super(array, itemSize, normalized);
@@ -81254,7 +81265,41 @@ return ${compiler2.callType("value", tagType)}
   var classicSkinTextureCoordinates = {
     ...baseSkinCoordinates
   };
-  var slimSkinTextureCoordinates = { ...baseSkinCoordinates };
+  var slimSkinTextureCoordinates = {
+    ...baseSkinCoordinates,
+    leftArm: {
+      ...baseSkinCoordinates.leftArm,
+      west: { uv: [39, 52, 43, 64] },
+      north: { uv: [36, 52, 39, 64] },
+      south: { uv: [43, 52, 46, 64] },
+      up: { uv: [39, 52, 36, 48] },
+      down: { uv: [42, 48, 39, 52] }
+    },
+    rightArm: {
+      ...baseSkinCoordinates.rightArm,
+      west: { uv: [47, 20, 51, 32] },
+      north: { uv: [44, 20, 47, 32] },
+      south: { uv: [51, 20, 54, 32] },
+      up: { uv: [47, 20, 44, 16] },
+      down: { uv: [50, 16, 47, 20] }
+    },
+    leftSleeve: {
+      ...baseSkinCoordinates.leftSleeve,
+      west: { uv: [55, 52, 59, 64] },
+      north: { uv: [52, 52, 55, 64] },
+      south: { uv: [59, 52, 62, 64] },
+      up: { uv: [55, 52, 52, 48] },
+      down: { uv: [58, 48, 55, 52], rotation: 180 }
+    },
+    rightSleeve: {
+      ...baseSkinCoordinates.rightSleeve,
+      west: { uv: [47, 36, 51, 48] },
+      north: { uv: [44, 36, 47, 48] },
+      south: { uv: [51, 36, 54, 48] },
+      up: { uv: [47, 36, 44, 32] },
+      down: { uv: [50, 32, 47, 36], rotation: 180 }
+    }
+  };
 
   // src/skin/SkinGeometries.ts
   init_dirname();
@@ -81298,14 +81343,98 @@ return ${compiler2.callType("value", tagType)}
 
   // src/skin/scene/SkinObject.ts
   var import_ts_deepmerge7 = __toESM(require_dist());
+
+  // src/skin/SkinTextures.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var SkinTextures = class {
+    static async get(src, legacy) {
+      const image = await ImageLoader.getData(src);
+      const scale = image.width / 64;
+      if (!Number.isInteger(scale) || scale < 1 || image.height !== image.width && image.height !== image.width / 2) {
+        throw new MineRenderError(`Invalid skin dimensions ${image.width}x${image.height}; expected 64x64 or 64x32, or an integer-scaled equivalent`);
+      }
+      const isLegacy = legacy ?? image.height === image.width / 2;
+      if (!isLegacy && image.height !== image.width) {
+        throw new MineRenderError(`Invalid skin dimensions ${image.width}x${image.height}; non-legacy skins must be square`);
+      }
+      const slim = !isLegacy && this.isSlim(image, scale);
+      const key = `skin:${serializeImageKey({ src })}:${isLegacy}`;
+      const material = Caching.materialCache.get(key, () => {
+        const pixels = isLegacy ? this.normalizeLegacy(image, scale) : new Uint8Array(image.data);
+        const texture = Textures.initTextureProps(new DataTexture(pixels, image.width, image.width));
+        texture.colorSpace = SRGBColorSpace;
+        texture.flipY = true;
+        texture.needsUpdate = true;
+        return new MeshBasicMaterial({ map: texture, transparent: true, side: DoubleSide, alphaTest: 0.5 });
+      });
+      return { material, slim, legacy: isLegacy };
+    }
+    static isSlim(image, scale) {
+      for (const [x4, y5] of [[46, 52], [54, 20]]) {
+        for (let row = y5 * scale; row < (y5 + 12) * scale; row++) {
+          for (let column = x4 * scale; column < (x4 + 1) * scale; column++) {
+            if (image.data[(row * image.width + column) * 4 + 3] !== 0) return false;
+          }
+        }
+      }
+      return true;
+    }
+    static normalizeLegacy(image, scale) {
+      const pixels = new Uint8Array(image.width * image.width * 4);
+      pixels.set(image.data.subarray(0, image.width * image.width / 2 * 4));
+      for (const [sx, sy, dx, dy, width, height] of [
+        [4, 16, 20, 48, 4, 4],
+        [8, 16, 24, 48, 4, 4],
+        [0, 20, 24, 52, 4, 12],
+        [4, 20, 20, 52, 4, 12],
+        [8, 20, 16, 52, 4, 12],
+        [12, 20, 28, 52, 4, 12],
+        [44, 16, 36, 48, 4, 4],
+        [48, 16, 40, 48, 4, 4],
+        [40, 20, 40, 52, 4, 12],
+        [44, 20, 36, 52, 4, 12],
+        [48, 20, 32, 52, 4, 12],
+        [52, 20, 44, 52, 4, 12]
+      ]) {
+        for (let y5 = 0; y5 < height * scale; y5++) {
+          for (let x4 = 0; x4 < width * scale; x4++) {
+            const source = ((sy * scale + y5) * image.width + sx * scale + x4) * 4;
+            const target = ((dy * scale + y5) * image.width + (dx + width) * scale - 1 - x4) * 4;
+            pixels.set(image.data.subarray(source, source + 4), target);
+          }
+        }
+      }
+      let clearHat = true;
+      for (let y5 = 0; y5 < 32 * scale; y5++) {
+        for (let x4 = 32 * scale; x4 < image.width; x4++) {
+          if (pixels[(y5 * image.width + x4) * 4 + 3] < 128) clearHat = false;
+        }
+      }
+      for (let y5 = 0; y5 < image.width; y5++) {
+        for (let x4 = 0; x4 < image.width; x4++) {
+          const alpha = (y5 * image.width + x4) * 4 + 3;
+          if (x4 < 32 * scale && y5 < 16 * scale || y5 >= 16 * scale && y5 < 32 * scale || x4 >= 16 * scale && x4 < 48 * scale && y5 >= 48 * scale) {
+            pixels[alpha] = 255;
+          } else if (clearHat && x4 >= 32 * scale && y5 < 32 * scale) {
+            pixels[alpha] = 0;
+          }
+        }
+      }
+      return pixels;
+    }
+  };
+
+  // src/skin/scene/SkinObject.ts
   var SkinObject = class extends SceneObject {
     constructor(options) {
       super();
       this.slim = false;
-      this.legacy = false;
-      this.skinTextureWidth = 64;
-      this.skinTextureHeight = 64;
+      this.detectedSlim = false;
+      this.skinLoad = 0;
       this.options = (0, import_ts_deepmerge7.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
+      this.slim = this.options.slim ?? false;
     }
     async init() {
       this.createMeshes();
@@ -81314,15 +81443,13 @@ return ${compiler2.callType("value", tagType)}
     }
     createMeshes() {
       console.log("#createMeshes");
-      const mat = Materials.MISSING_TEXTURE;
+      const mat = this.skinMaterial ?? Materials.MISSING_TEXTURE;
       {
         const headGroup = this.createAndAddGroup("head", 0, 28, 0, "y" /* Y */, -4);
         const headGeo = this.getBoxGeometry("head" /* HEAD */);
         const head = this.createAndAddMesh("head", headGroup, headGeo, mat, "y" /* Y */, 4);
-        if (!this.legacy) {
-          const hatGeo = this.getBoxGeometry("hat" /* HAT */);
-          const hat = this.createAndAddMesh("hat", headGroup, hatGeo, mat, "y" /* Y */, 4);
-        }
+        const hatGeo = this.getBoxGeometry("hat" /* HAT */);
+        const hat = this.createAndAddMesh("hat", headGroup, hatGeo, mat, "y" /* Y */, 4);
       }
       {
         const bodyGroup = this.createAndAddGroup("body", 0, 18, 0);
@@ -81365,46 +81492,59 @@ return ${compiler2.callType("value", tagType)}
       }
       console.log("#createMeshes done");
     }
-    setSkinTexture(src) {
+    async setSkinTexture(src) {
       if (typeof src === "undefined") return;
       this.skinTextureSrc = src;
-      const mat = Materials.getImage({
-        texture: { src },
-        transparent: true
-      });
-      for (let part of SKIN_PARTS) {
-        let mesh = this.getMeshByName(part);
+      const load = ++this.skinLoad;
+      const texture = await SkinTextures.get(src, this.options.legacy);
+      if (load !== this.skinLoad) return;
+      this.skinMaterial = texture.material;
+      this.detectedSlim = texture.slim;
+      this.updateSlim(this.options.slim ?? this.detectedSlim);
+      for (const part of SKIN_PARTS) {
+        const mesh = this.getMeshByName(part);
         if (mesh) {
-          mesh.material = mat;
+          mesh.material = texture.material;
         }
       }
+      this.notifyDirty();
     }
     //TODO: cape
+    /** Select the arm model, or pass undefined to use texture detection. */
     setSlim(slim) {
-      console.log("#setSlim");
-      const changed = slim !== this.slim;
+      this.options.slim = slim;
+      this.updateSlim(slim ?? this.detectedSlim);
+    }
+    updateSlim(slim) {
+      if (slim === this.slim) return;
       this.slim = slim;
-      if (changed) {
-        this.createMeshes();
-      }
-      if (changed) {
-        if (this.skinTextureSrc) {
-          this.setSkinTexture(this.skinTextureSrc);
-        }
-      }
-      console.log("#setSlim done");
+      for (const part of ["leftArm" /* LEFT_ARM */, "leftSleeve" /* LEFT_SLEEVE */, "rightArm" /* RIGHT_ARM */, "rightSleeve" /* RIGHT_SLEEVE */]) {
+        const mesh = this.getMeshByName(part);
+        if (mesh) mesh.geometry = this.getBoxGeometry(part);
+      }
+      const offset = slim ? 0.5 : -0.5;
+      const leftArm = this.getGroupByName("leftArm" /* LEFT_ARM */);
+      const rightArm = this.getGroupByName("rightArm" /* RIGHT_ARM */);
+      if (leftArm) leftArm.position.x += offset;
+      if (rightArm) rightArm.position.x -= offset;
+      this.notifyDirty();
     }
-    setLegacy(legacy) {
-      if (legacy !== this.legacy) {
-      }
-      this.legacy = legacy;
+    /** Select the texture layout, or pass undefined to detect it from image dimensions. */
+    async setLegacy(legacy) {
+      if (legacy === this.options.legacy) return;
+      this.options.legacy = legacy;
+      if (this.skinTextureSrc) await this.setSkinTexture(this.skinTextureSrc);
+    }
+    dispose() {
+      this.skinLoad++;
+      super.dispose();
     }
     //TODO: layer toggles
     getBoxGeometry(part) {
       console.log("slim", this.slim);
       const coordinates = this.slim ? slimSkinTextureCoordinates : classicSkinTextureCoordinates;
       const geometries = this.slim ? slimSkinGeometries : classicSkinGeometries;
-      return this._getBoxGeometryFromDimensions(geometries[part], coordinates[part], [64, 64], [this.skinTextureWidth, this.skinTextureHeight]);
+      return this._getBoxGeometryFromDimensions(geometries[part], coordinates[part], [64, 64], [64, 64]);
     }
   };
 
@@ -81514,10 +81654,10 @@ return ${compiler2.callType("value", tagType)}
       this.dirty = true;
       const obj = new SkinObject(options);
       obj.scene = this;
-      await obj.init();
       if (skin) {
-        obj.setSkinTexture(skin);
+        await obj.setSkinTexture(skin);
       }
+      await obj.init();
       parent.add(obj);
       return obj;
     }