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

package/dist/node/index.mjs

@@ -5506,7 +5506,41 @@ var baseSkinCoordinates = {
 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
 var box8inner = [8, 8, 8];
@@ -5547,14 +5581,96 @@ var slimSkinGeometries = {
 
 // src/skin/scene/SkinObject.ts
 var import_ts_deepmerge7 = __toESM(require_dist());
+
+// src/skin/SkinTextures.ts
+import { DataTexture, DoubleSide as DoubleSide2, MeshBasicMaterial as MeshBasicMaterial3, SRGBColorSpace as SRGBColorSpace3 } from "three";
+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 = SRGBColorSpace3;
+      texture.flipY = true;
+      texture.needsUpdate = true;
+      return new MeshBasicMaterial3({ map: texture, transparent: true, side: DoubleSide2, alphaTest: 0.5 });
+    });
+    return { material, slim, legacy: isLegacy };
+  }
+  static isSlim(image, scale) {
+    for (const [x, y] of [[46, 52], [54, 20]]) {
+      for (let row = y * scale; row < (y + 12) * scale; row++) {
+        for (let column = x * scale; column < (x + 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 y = 0; y < height * scale; y++) {
+        for (let x = 0; x < width * scale; x++) {
+          const source = ((sy * scale + y) * image.width + sx * scale + x) * 4;
+          const target = ((dy * scale + y) * image.width + (dx + width) * scale - 1 - x) * 4;
+          pixels.set(image.data.subarray(source, source + 4), target);
+        }
+      }
+    }
+    let clearHat = true;
+    for (let y = 0; y < 32 * scale; y++) {
+      for (let x = 32 * scale; x < image.width; x++) {
+        if (pixels[(y * image.width + x) * 4 + 3] < 128) clearHat = false;
+      }
+    }
+    for (let y = 0; y < image.width; y++) {
+      for (let x = 0; x < image.width; x++) {
+        const alpha = (y * image.width + x) * 4 + 3;
+        if (x < 32 * scale && y < 16 * scale || y >= 16 * scale && y < 32 * scale || x >= 16 * scale && x < 48 * scale && y >= 48 * scale) {
+          pixels[alpha] = 255;
+        } else if (clearHat && x >= 32 * scale && y < 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();
@@ -5563,15 +5679,13 @@ var SkinObject = class extends SceneObject {
   }
   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);
@@ -5614,46 +5728,59 @@ var SkinObject = class extends SceneObject {
     }
     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]);
   }
 };
 
@@ -5766,10 +5893,10 @@ var MineRenderScene = class _MineRenderScene extends Scene2 {
     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;
   }
@@ -5782,7 +5909,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace3, Vector3 as Vector39, WebGLRenderer } from "three";
+import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace4, Vector3 as Vector39, WebGLRenderer } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 import Stats from "stats.js";
 import { EffectComposer, RenderPass } from "postprocessing";
@@ -6536,7 +6663,7 @@ var Renderer = class _Renderer {
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
     renderer.shadowMap.type = PCFSoftShadowMap;
-    renderer.outputColorSpace = SRGBColorSpace3;
+    renderer.outputColorSpace = SRGBColorSpace4;
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
@@ -7243,6 +7370,7 @@ export {
   SchematicParser,
   SkinObject,
   SkinPart,
+  SkinTextures,
   Skins,
   StructureParser,
   TextureAtlas,