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

package/dist/node/index.mjs

@@ -1090,7 +1090,7 @@ var Meshes = class _Meshes {
 };
 
 // src/UVMapper.ts
-import { Float32BufferAttribute as Float32BufferAttribute2, Vector2 } from "three";
+import { Float32BufferAttribute as Float32BufferAttribute2, Vector2, Vector3 as Vector33 } from "three";
 
 // src/model/ModelMerger.ts
 var import_ts_deepmerge = __toESM(require_dist());
@@ -2091,6 +2091,14 @@ var DEFAULT_UV = [0, 0, 16, 16];
 var X = 0;
 var Y = 1;
 var Z = 2;
+var FACE_UV_AXES = {
+  east: [new Vector33(0, 0, -1), new Vector33(0, -1, 0)],
+  west: [new Vector33(0, 0, 1), new Vector33(0, -1, 0)],
+  up: [new Vector33(1, 0, 0), new Vector33(0, 0, 1)],
+  down: [new Vector33(1, 0, 0), new Vector33(0, 0, -1)],
+  south: [new Vector33(1, 0, 0), new Vector33(0, -1, 0)],
+  north: [new Vector33(-1, 0, 0), new Vector33(0, -1, 0)]
+};
 var UVMapper = class {
   static makeUv(uvCoord, originalTextureSize, actualTextureSize) {
     if (uvCoord === 0) return 0;
@@ -2188,6 +2196,42 @@ var UVMapper = class {
   static facesToUv(faces, originalTextureSize, actualTextureSize) {
     return new Float32BufferAttribute2(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((name) => {
+        const [u, v] = FACE_UV_AXES[name];
+        return v.clone().cross(u).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 u = (uv.getX(index) * atlas.image.width - position[0]) / size[0] - 0.5;
+        const v = ((1 - uv.getY(index)) * atlas.image.height - position[1]) / size[1] - 0.5;
+        const lockedU = uu * u + uvCross * v + 0.5;
+        const lockedV = vu * u + vv * v + 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, (k) => {
@@ -2634,7 +2678,7 @@ var BlockEntityModels = class {
 };
 
 // src/renderer/SceneObject.ts
-import { Euler, InstancedMesh, MathUtils, Matrix4 as Matrix42, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion2, Vector3 as Vector33 } from "three";
+import { Euler as Euler2, InstancedMesh, MathUtils, Matrix4 as Matrix42, Mesh as Mesh3, Object3D as Object3D2, Quaternion as Quaternion2, Vector3 as Vector34 } from "three";
 
 // src/instance/InstanceReference.ts
 var InstanceReference = class {
@@ -2802,6 +2846,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   createInstancedMesh(name, geometry, material, count) {
     const mesh = new InstancedMesh(geometry, material, count);
+    mesh.count = 0;
     if (name) {
       mesh.name = `mesh:${name}`;
     }
@@ -2879,6 +2924,10 @@ var SceneObject = class _SceneObject extends Object3D2 {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const i = this._instanceCounter++;
     this.setMatrixAt(i, new Matrix42());
+    const mesh = this.children[0];
+    if (mesh && isInstancedMesh(mesh)) {
+      mesh.count = Math.min(this._instanceCounter, mesh.instanceMatrix.count);
+    }
     console.debug(p6, "nextInstance " + i);
     if (i === this.options.maxInstanceCount) {
       console.warn(p6, "Max instance count reached for " + this);
@@ -2910,9 +2959,9 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   setPositionRotationScaleAt(index, position, rotation, scale) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-    const oldPosition = new Vector33();
+    const oldPosition = new Vector34();
     const oldRotation = new Quaternion2();
-    const oldScale = new Vector33();
+    const oldScale = new Vector34();
     const matrix = new Matrix42();
     if (!scale || !rotation || !position) {
       this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
@@ -2928,7 +2977,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, position);
   }
-  getPositionAt(index, vector = new Vector33()) {
+  getPositionAt(index, vector = new Vector34()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     vector.setFromMatrixPosition(matrix);
@@ -2938,7 +2987,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, void 0, rotation, void 0);
   }
-  getRotationAt(index, euler = new Euler()) {
+  getRotationAt(index, euler = new Euler2()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     euler.setFromRotationMatrix(matrix);
@@ -2948,7 +2997,7 @@ var SceneObject = class _SceneObject extends Object3D2 {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, void 0, void 0, scale);
   }
-  getScaleAt(index, vector = new Vector33()) {
+  getScaleAt(index, vector = new Vector34()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     vector.setFromMatrixScale(matrix);
@@ -3606,7 +3655,7 @@ function isQuadArray(obj) {
 }
 
 // src/model/scene/ModelObject.ts
-import { BoxGeometry as BoxGeometry5, Matrix4 as Matrix45 } from "three";
+import { BoxGeometry as BoxGeometry5, Euler as Euler4, Matrix4 as Matrix45 } from "three";
 
 // src/three/BufferGeometryUtils.js
 import {
@@ -3618,7 +3667,7 @@ import {
   TriangleFanDrawMode,
   TriangleStripDrawMode,
   TrianglesDrawMode,
-  Vector3 as Vector35
+  Vector3 as Vector36
 } from "three";
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -3937,15 +3986,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new Vector35();
-  const _vB = new Vector35();
-  const _vC = new Vector35();
-  const _tempA = new Vector35();
-  const _tempB = new Vector35();
-  const _tempC = new Vector35();
-  const _morphA = new Vector35();
-  const _morphB = new Vector35();
-  const _morphC = new Vector35();
+  const _vA = new Vector36();
+  const _vB = new Vector36();
+  const _vC = new Vector36();
+  const _tempA = new Vector36();
+  const _tempB = new Vector36();
+  const _tempC = new Vector36();
+  const _morphA = new Vector36();
+  const _morphB = new Vector36();
+  const _morphC = new Vector36();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4189,6 +4238,9 @@ var ModelObject = class _ModelObject extends SceneObject {
       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 Euler4(...this.options.uvLockRotation));
+          }
           elGeo.applyMatrix4(new Matrix45().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 Matrix45().makeTranslation(el.from[0], el.from[1], el.from[2]));
           if (el.rotation) {
@@ -4266,7 +4318,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-import { Euler as Euler3, Matrix4 as Matrix46, Vector3 as Vector36 } from "three";
+import { Euler as Euler5, Matrix4 as Matrix46, Vector3 as Vector37 } from "three";
 var p10 = prefix("BlockObject");
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
@@ -4328,7 +4380,7 @@ var BlockObject = class _BlockObject extends SceneObject {
       if (isModelObject(model)) {
         model.removeFromScene();
       } else if (isInstanceReference(model)) {
-        model.setScale(new Vector36(0, 0, 0));
+        model.setScale(new Vector37(0, 0, 0));
       }
     }
     super.removeFromScene();
@@ -4389,7 +4441,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     }
     for (let model of this._models) {
       if (isInstanceReference(model)) {
-        model.setScale(new Vector36(0, 0, 0));
+        model.setScale(new Vector37(0, 0, 0));
       } else {
         model.dispose();
       }
@@ -4426,25 +4478,24 @@ var BlockObject = class _BlockObject extends SceneObject {
     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 Euler3(0, 0, 0);
+    const rotation = new Euler5();
     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() {
@@ -5506,7 +5557,8 @@ var MineRenderScene = class _MineRenderScene extends Scene2 {
     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();
@@ -5549,7 +5601,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper3, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace3, Vector3 as Vector38, WebGLRenderer } from "three";
+import { AxesHelper as AxesHelper3, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace3, Vector3 as Vector39, WebGLRenderer } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 import Stats from "stats.js";
 import { EffectComposer, RenderPass } from "postprocessing";
@@ -5562,7 +5614,7 @@ import {
   Spherical,
   TOUCH,
   Vector2 as Vector23,
-  Vector3 as Vector37
+  Vector3 as Vector38
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
@@ -5576,7 +5628,7 @@ var OrbitControls = class extends EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector37();
+    this.target = new Vector38();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -5628,10 +5680,10 @@ var OrbitControls = class extends EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector37();
-      const quat = new Quaternion3().setFromUnitVectors(object.up, new Vector37(0, 1, 0));
+      const offset = new Vector38();
+      const quat = new Quaternion3().setFromUnitVectors(object.up, new Vector38(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector37();
+      const lastPosition = new Vector38();
       const lastQuaternion = new Quaternion3();
       const twoPI = 2 * Math.PI;
       return function update() {
@@ -5721,7 +5773,7 @@ var OrbitControls = class extends EventDispatcher {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector37();
+    const panOffset = new Vector38();
     let zoomChanged = false;
     const rotateStart = new Vector23();
     const rotateEnd = new Vector23();
@@ -5747,7 +5799,7 @@ var OrbitControls = class extends EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector37();
+      const v = new Vector38();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -5755,7 +5807,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new Vector37();
+      const v = new Vector38();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -5768,7 +5820,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new Vector37();
+      const offset = new Vector38();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -6245,8 +6297,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new Vector38(50, 50, 50),
-        lookingAt: new Vector38(0, 0, 0)
+        position: new Vector39(50, 50, 50),
+        lookingAt: new Vector39(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -6550,7 +6602,7 @@ var Skins = class {
     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) => {
@@ -6577,7 +6629,7 @@ var Skins = class {
     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) => {
@@ -6598,8 +6650,23 @@ var Skins = class {
   //</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",
@@ -6678,20 +6745,28 @@ var Skins = class {
   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>
 };
 
 // src/world/Chunk.ts
-import { Box3 as Box32, Object3D as Object3D6, Vector3 as Vector310 } from "three";
+import { Box3 as Box32, Object3D as Object3D6, Vector3 as Vector311 } from "three";
 
 // src/world/MineRenderWorld.ts
-import { Vector3 as Vector39 } from "three";
+import { Vector3 as Vector310 } from "three";
 var MineRenderWorld = class {
   constructor(scene) {
     this._size = 4;
@@ -6702,10 +6777,10 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector39(posOrX, y, z));
+      return this.getBlockAt(new Vector310(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector39(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]));
     }
     const chunk = this.getChunkAt(posOrX);
     if (typeof chunk === "undefined") {
@@ -6716,10 +6791,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector39(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector310(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector39(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
     const chunk = this.getOrCreateChunkAt(posOrX);
@@ -6765,14 +6840,14 @@ var MineRenderWorld = class {
     return this._chunks[index];
   }
   static worldToScenePosition(pos) {
-    return new Vector39(
+    return new Vector310(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new Vector39(
+    return new Vector310(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -6814,7 +6889,7 @@ var Chunk = class _Chunk {
     scene.add(anchor);
     anchor.position.set(this.x * 256 + 128 - 8, this.y * 256 + 128 - 8, this.z * 256 + 128 - 8);
     addBox3WireframeToObject(
-      new Box32(new Vector310(0, 0, 0), new Vector310(256, 256, 256)),
+      new Box32(new Vector311(0, 0, 0), new Vector311(256, 256, 256)),
       anchor,
       16776960,
       4
@@ -6822,10 +6897,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector310(posOrX, y, z));
+      return this.getBlockAt(new Vector311(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -6833,10 +6908,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector310(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector311(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -6882,7 +6957,7 @@ var Chunk = class _Chunk {
   }
   async clear() {
     let promises = [];
-    let pos = new Vector310();
+    let pos = new Vector311();
     for (let x = 0; x < 16; x++) {
       for (let z = 0; z < 16; z++) {
         for (let y = 0; y < 16; y++) {
@@ -6901,14 +6976,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector310(
+    return new Vector311(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector310(
+    return new Vector311(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z