minerender 2.1.0-alpha.18 → 2.1.0-alpha.19

package/dist/bundle.js

@@ -77622,6 +77622,14 @@ return ${compiler2.callType("value", tagType)}
   var X3 = 0;
   var Y4 = 1;
   var Z3 = 2;
+  var FACE_UV_AXES = {
+    east: [new Vector3(0, 0, -1), new Vector3(0, -1, 0)],
+    west: [new Vector3(0, 0, 1), new Vector3(0, -1, 0)],
+    up: [new Vector3(1, 0, 0), new Vector3(0, 0, 1)],
+    down: [new Vector3(1, 0, 0), new Vector3(0, 0, -1)],
+    south: [new Vector3(1, 0, 0), new Vector3(0, -1, 0)],
+    north: [new Vector3(-1, 0, 0), new Vector3(0, -1, 0)]
+  };
   var UVMapper = class {
     static makeUv(uvCoord, originalTextureSize, actualTextureSize) {
       if (uvCoord === 0) return 0;
@@ -77719,6 +77727,42 @@ return ${compiler2.callType("value", tagType)}
     static facesToUv(faces, originalTextureSize, actualTextureSize) {
       return new Float32BufferAttribute(this.facesToUvArray(faces, originalTextureSize, actualTextureSize), 2);
     }
+    static lockUvs(geometry, faces, atlas, rotation) {
+      const uv = geometry.getAttribute("uv");
+      for (let faceIndex = 0; faceIndex < CUBE_FACES.length; faceIndex++) {
+        const faceName = CUBE_FACES[faceIndex];
+        const texture = faces[faceName]?.texture?.substring(1);
+        const position = texture && atlas.positions[texture];
+        const size = texture && atlas.sizes[texture];
+        if (!position || !size) continue;
+        const [sourceU, sourceV] = FACE_UV_AXES[faceName];
+        const uAxis = sourceU.clone().applyEuler(rotation);
+        const vAxis = sourceV.clone().applyEuler(rotation);
+        const normal = vAxis.clone().cross(uAxis);
+        const targetFace = CUBE_FACES.find((name2) => {
+          const [u4, v5] = FACE_UV_AXES[name2];
+          return v5.clone().cross(u4).dot(normal) > 0.5;
+        });
+        const [targetU, targetV] = FACE_UV_AXES[targetFace];
+        const uu = Math.round(targetU.dot(uAxis));
+        const uvCross = Math.round(targetU.dot(vAxis));
+        const vu = Math.round(targetV.dot(uAxis));
+        const vv = Math.round(targetV.dot(vAxis));
+        for (let corner = 0; corner < 4; corner++) {
+          const index = faceIndex * 4 + corner;
+          const u4 = (uv.getX(index) * atlas.image.width - position[0]) / size[0] - 0.5;
+          const v5 = ((1 - uv.getY(index)) * atlas.image.height - position[1]) / size[1] - 0.5;
+          const lockedU = uu * u4 + uvCross * v5 + 0.5;
+          const lockedV = vu * u4 + vv * v5 + 0.5;
+          uv.setXY(
+            index,
+            (position[0] + lockedU * size[0]) / atlas.image.width,
+            1 - (position[1] + lockedV * size[1]) / atlas.image.height
+          );
+        }
+      }
+      uv.needsUpdate = true;
+    }
     static async getAtlas(model) {
       const keyStr = model.key.serialize();
       return Caching.modelTextureAtlasCache.get(keyStr, (k4) => {
@@ -78418,6 +78462,7 @@ return ${compiler2.callType("value", tagType)}
     }
     createInstancedMesh(name2, geometry, material, count) {
       const mesh = new InstancedMesh(geometry, material, count);
+      mesh.count = 0;
       if (name2) {
         mesh.name = `mesh:${name2}`;
       }
@@ -78495,6 +78540,10 @@ return ${compiler2.callType("value", tagType)}
       if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
       const i4 = this._instanceCounter++;
       this.setMatrixAt(i4, new Matrix4());
+      const mesh = this.children[0];
+      if (mesh && isInstancedMesh(mesh)) {
+        mesh.count = Math.min(this._instanceCounter, mesh.instanceMatrix.count);
+      }
       console.debug(p9, "nextInstance " + i4);
       if (i4 === this.options.maxInstanceCount) {
         console.warn(p9, "Max instance count reached for " + this);
@@ -79897,6 +79946,9 @@ return ${compiler2.callType("value", tagType)}
         if (this.atlas.model.elements) {
           this.atlas.model.elements?.forEach((el) => {
             const elGeo = this._getBoxGeometryFromElement(el).clone();
+            if (this.options.uvLockRotation) {
+              UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler(...this.options.uvLockRotation));
+            }
             elGeo.applyMatrix4(new Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
             elGeo.applyMatrix4(new Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
             if (el.rotation) {
@@ -80130,25 +80182,24 @@ return ${compiler2.callType("value", tagType)}
       await this.createVariant(variant);
     }
     async createVariant(variant) {
-      const model = await Models.getMerged(AssetKey.parse("models", variant.model));
-      const obj = await this.scene.addModel(model, this.options);
-      if (isInstanceReference(obj) || obj.isInstanced) {
-        this._isInstanced = true;
-        this._instanceCounter = 1;
-      }
-      let rotation = new Euler(0, 0, 0);
+      const rotation = new Euler();
       if (typeof variant.x !== "undefined") {
         rotation.x = toRadians(clampRotationDegrees(variant.x));
       }
       if (typeof variant.y !== "undefined") {
-        if (typeof variant.x !== "undefined") {
-          rotation.y = toRadians(clampRotationDegrees(variant.y));
-        } else {
-          rotation.y = toRadians(clampRotationDegrees(360 - variant.y));
-        }
+        rotation.y = toRadians(clampRotationDegrees(typeof variant.x !== "undefined" ? variant.y : 360 - variant.y));
+      }
+      const model = await Models.getMerged(AssetKey.parse("models", variant.model));
+      const options = {
+        ...this.options,
+        uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
+      };
+      const obj = await this.scene.addModel(model, options);
+      if (isInstanceReference(obj) || obj.isInstanced) {
+        this._isInstanced = true;
+        this._instanceCounter = 1;
       }
       obj.setRotation(rotation);
-      console.log(obj);
       return obj;
     }
     async resetState() {
@@ -81253,7 +81304,8 @@ return ${compiler2.callType("value", tagType)}
       const obj = await objectSupplier();
       if (obj?.options?.instanceMeshes && asset.key && asset.key?.assetType === "models") {
         console.log("instanceMeshes + key");
-        const key = asset.key.serialize();
+        const uvLockRotation = isModelObject(obj) ? obj.options.uvLockRotation : void 0;
+        const key = asset.key.serialize() + (uvLockRotation ? `|uvlock:${uvLockRotation.join(",")}` : "");
         return this.instanceManager.getOrCreate(key, async () => {
           obj.scene = this;
           await obj.init();
@@ -84069,7 +84121,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       return this.fromUsername(uuidOrUsername);
     }
     static async fromUuid(uuid) {
-      return this.getSkinProxySkinUrl(uuid);
+      return this.getMcProxySkinUrl(uuid);
     }
     static async fromUsername(username) {
       return this.usernameToUuid(username).then((uuid) => {
@@ -84096,7 +84148,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       return this.capeFromUsername(uuidOrUsername);
     }
     static async capeFromUuid(uuid) {
-      return this.getSkinProxyCapeUrl(uuid);
+      return this.getMcProxyCapeUrl(uuid);
     }
     static async capeFromUsername(username) {
       return this.usernameToUuid(username).then((uuid) => {
@@ -84117,8 +84169,23 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     //</editor-fold>
     //<editor-fold desc="Helpers">
     static async usernameToUuid(username) {
-      return this.usernameToUuidSkinProxy(username);
+      return this.usernameToUuidMcProxy(username);
+    }
+    static async usernameToUuidMcProxy(username) {
+      return Requests.genericRequest({
+        baseURL: "https://mcproxy.dev",
+        url: "/uuid/" + username
+      }).then((res) => {
+        if (res.status === 200) {
+          return res.data["data"]["id"];
+        }
+        return void 0;
+      }).catch((err) => {
+        console.warn(err);
+        return void 0;
+      });
     }
+    /** @deprecated **/
     static async usernameToUuidSkinProxy(username) {
       return Requests.genericRequest({
         baseURL: "https://minecraft-skin-proxy.inventive.workers.dev",
@@ -84197,12 +84264,20 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     static getMineSkinPlayerSkinUrl(uuid) {
       return "https://mineskin.org/skin/player/" + uuid;
     }
+    /** @deprecated **/
     static getSkinProxySkinUrl(uuid) {
       return "https://minecraft-skin-proxy.inventive.workers.dev/skin/" + uuid;
     }
+    /** @deprecated **/
     static getSkinProxyCapeUrl(uuid) {
       return "https://minecraft-skin-proxy.inventive.workers.dev/cape/" + uuid;
     }
+    static getMcProxySkinUrl(uuid) {
+      return "https://mcproxy.dev/skin/" + uuid;
+    }
+    static getMcProxyCapeUrl(uuid) {
+      return "https://mcproxy.dev/cape/" + uuid;
+    }
     //</editor-fold>
   };