minerender 2.1.0-alpha.37 → 2.1.0-alpha.38

package/dist/bundle.js

@@ -48096,6 +48096,7 @@ return ${compiler2.callType("value", tagType)}
     BrowserCache: () => BrowserCache,
     BrowserEnv: () => BrowserEnv,
     CUBE_FACES: () => CUBE_FACES,
+    CUBE_FACE_OFFSETS: () => CUBE_FACE_OFFSETS,
     Caching: () => Caching,
     CanvasImage: () => CanvasImage,
     Chunk: () => Chunk,
@@ -48129,6 +48130,7 @@ return ${compiler2.callType("value", tagType)}
     MineRenderWorld: () => MineRenderWorld,
     MinecraftCubeTexture: () => MinecraftCubeTexture,
     MinecraftFaceUV: () => MinecraftFaceUV,
+    ModelCulling: () => ModelCulling,
     ModelGenerator: () => ModelGenerator,
     ModelMerger: () => ModelMerger,
     ModelObject: () => ModelObject,
@@ -68052,6 +68054,14 @@ return ${compiler2.callType("value", tagType)}
     return CubeFaceIndex2;
   })(CubeFaceIndex || {});
   var CUBE_FACES = Object.values(CubeFace);
+  var CUBE_FACE_OFFSETS = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 1, 0],
+    [0, -1, 0],
+    [0, 0, 1],
+    [0, 0, -1]
+  ];
 
   // src/Disposable.ts
   init_dirname();
@@ -82275,6 +82285,44 @@ ${key}` : key;
     return Array.isArray(obj) && obj.length === 4;
   }
 
+  // src/model/ModelCulling.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var ModelCulling = class {
+    static toLocalMask(worldMask, rotation) {
+      let localMask = 0;
+      for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
+        const normal = new Vector3(...offset).applyEuler(rotation);
+        const worldFace = CUBE_FACE_OFFSETS.findIndex(([x4, y5, z4]) => Math.abs(normal.x - x4) < 1e-6 && Math.abs(normal.y - y5) < 1e-6 && Math.abs(normal.z - z4) < 1e-6);
+        if (worldFace < 0) return 0;
+        if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
+      }
+      return localMask;
+    }
+    static isOpaqueFullCube(atlas) {
+      if (!atlas || atlas.hasTransparency !== false || atlas.model.elements?.length !== 1) return false;
+      const element = atlas.model.elements[0];
+      if (element.from.length !== 3 || !element.from.every((value) => value === 0) || element.to.length !== 3 || !element.to.every((value) => value === 16) || element.rotation && element.rotation.angle !== 0 || element.mappedUv?.length !== 48 || !element.mappedUv.every(Number.isFinite)) return false;
+      if (!(atlas.image.width > 0 && atlas.image.height > 0)) return false;
+      return CUBE_FACES.every((face, faceIndex) => {
+        const texture = element.faces[face]?.texture;
+        if (!texture?.startsWith("#")) return false;
+        const key = texture.slice(1);
+        const position = atlas.positions[key];
+        const size = atlas.sizes[key];
+        if (position?.length !== 2 || !position.every(Number.isFinite) || size?.length !== 2 || !size.every((value) => value > 0 && Number.isFinite(value))) return false;
+        for (let vertex2 = 0; vertex2 < 4; vertex2++) {
+          const uvIndex = (faceIndex * 4 + vertex2) * 2;
+          const x4 = element.mappedUv[uvIndex] * atlas.image.width;
+          const y5 = (1 - element.mappedUv[uvIndex + 1]) * atlas.image.height;
+          if (x4 < position[0] - 1e-6 || x4 > position[0] + size[0] + 1e-6 || y5 < position[1] - 1e-6 || y5 > position[1] + size[1] + 1e-6) return false;
+        }
+        return true;
+      });
+    }
+  };
+
   // src/model/ModelElement.ts
   init_dirname();
   init_buffer2();
@@ -82960,6 +83008,9 @@ ${key}` : key;
     get textureAtlas() {
       return this.atlas;
     }
+    get isOpaqueFullCube() {
+      return !this.options.displayPosition && ModelCulling.isOpaqueFullCube(this.atlas);
+    }
     //TODO: support for replacing textures
     async loadTextures() {
       this.atlas = await UVMapper.getAtlas(this.originalModel);
@@ -82973,6 +83024,15 @@ ${key}` : key;
         if (this.atlas.model.elements) {
           this.atlas.model.elements?.forEach((el) => {
             const elGeo = this._getBoxGeometryFromElement(el).clone();
+            if (this.options.cullMask) {
+              const indices = Array.from(elGeo.getIndex().array);
+              elGeo.setIndex(indices.filter((_4, index) => {
+                const face = CUBE_FACES[Math.floor(index / 6)];
+                const direction = CUBE_FACES.findIndex((name2) => name2 === el.faces[face]?.cullface);
+                return direction < 0 || !(this.options.cullMask & 1 << direction);
+              }));
+              elGeo.clearGroups();
+            }
             if (this.options.uvLockRotation) {
               UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler(...this.options.uvLockRotation));
             }
@@ -83096,6 +83156,7 @@ ${key}` : key;
       this._instanceModel = [];
       this._variants = [];
       this._models = [];
+      this._cullMask = 0;
       this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
     }
     async init() {
@@ -83129,12 +83190,69 @@ ${key}` : key;
       super.removeFromScene();
     }
     clearModels() {
-      for (const model of this._models.splice(0)) {
+      this.removeModels(this._models.splice(0));
+      this._isInstanced = false;
+      this._instanceCounter = 0;
+    }
+    removeModels(models) {
+      for (const model of models) {
         model.removeFromScene();
         if (!isInstanceReference(model)) model.dispose();
       }
-      this._isInstanced = false;
-      this._instanceCounter = 0;
+    }
+    get isOccluding() {
+      return this._models.some((model) => {
+        const object = isInstanceReference(model) ? model.instanceable : model;
+        return object.isOpaqueFullCube && this.getModelCullMask(model, 63) === 63;
+      });
+    }
+    getModelMatrix(model) {
+      if (isInstanceReference(model)) return model.getMatrix();
+      if (model.matrixAutoUpdate) model.updateMatrix();
+      return model.matrix.clone();
+    }
+    getModelCullMask(model, worldMask) {
+      const object = isInstanceReference(model) ? model.instanceable : model;
+      if (object.options.displayPosition) return 0;
+      const position = new Vector3();
+      const rotation = new Quaternion();
+      const scale = new Vector3();
+      this.getModelMatrix(model).decompose(position, rotation, scale);
+      if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector3(1, 1, 1)) > 1e-10) return 0;
+      return ModelCulling.toLocalMask(worldMask, new Euler().setFromQuaternion(rotation));
+    }
+    async setCullMask(worldMask) {
+      worldMask &= 63;
+      const replacements = [];
+      try {
+        for (const model of this._models) {
+          const object = isInstanceReference(model) ? model.instanceable : model;
+          const cullMask = this.getModelCullMask(model, worldMask);
+          if (cullMask === (object.options.cullMask ?? 0)) {
+            replacements.push(model);
+            continue;
+          }
+          const matrix = this.getModelMatrix(model);
+          const replacement = await this.scene.addModel(object.originalModel, { ...object.options, cullMask });
+          replacements.push(replacement);
+          if (isInstanceReference(replacement)) {
+            replacement.setMatrix(matrix);
+          } else {
+            replacement.matrix.copy(matrix);
+            matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
+            replacement.matrixAutoUpdate = object.matrixAutoUpdate;
+            replacement.visible = object.visible;
+          }
+        }
+      } catch (error) {
+        this.removeModels(replacements.filter((model) => !this._models.includes(model)));
+        throw error;
+      }
+      const previous = this._models;
+      this._models = replacements;
+      this._cullMask = worldMask;
+      this.removeModels(previous.filter((model) => !replacements.includes(model)));
+      this.notifyDirty();
     }
     get state() {
       return this._state;
@@ -83227,7 +83345,8 @@ ${key}` : key;
       const options = {
         ...this.options,
         tints: model ? await BlockTints.get(this.blockState.key, this.state, model, this.options.tints) : this.options.tints,
-        uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
+        uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0,
+        cullMask: this.options.displayPosition ? 0 : ModelCulling.toLocalMask(this._cullMask, rotation)
       };
       const obj = await this.scene.addModel(model, options);
       if (isInstanceReference(obj) || obj.isInstanced) {
@@ -84539,11 +84658,12 @@ ${key}` : key;
         console.log("instanceMeshes + key");
         let key = asset.key.serialize();
         if (isModelObject(obj)) {
-          const { displayPosition, uvLockRotation, tints } = obj.options;
+          const { displayPosition, uvLockRotation, tints, cullMask } = obj.options;
           if (displayPosition) key += `|display:${displayPosition}`;
           if (uvLockRotation) key += `|uvlock:${uvLockRotation.join(",")}`;
           const palette = Object.entries(tints ?? {}).sort(([a4], [b4]) => Number(a4) - Number(b4));
           if (palette.length) key += `|tints:${JSON.stringify(palette)}`;
+          if (cullMask) key += `|cull:${cullMask}`;
         }
         return this.instanceManager.getOrCreate(key, async () => {
           obj.scene = this;
@@ -87635,6 +87755,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
   var MineRenderWorld = class {
     constructor(scene) {
       this._chunks = /* @__PURE__ */ new Map();
+      this.pendingCulling = /* @__PURE__ */ new Map();
       this.scene = scene;
     }
     getBlockAt(posOrX, y5, z4) {
@@ -87695,16 +87816,54 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       }
     }
     async clear() {
-      for (const chunk of this._chunks.values()) {
+      await this.culling;
+      const chunks = [...this._chunks.values()];
+      this._chunks.clear();
+      for (const chunk of chunks) {
         await chunk.dispose();
       }
-      this._chunks.clear();
+    }
+    updateCulling(positions) {
+      for (const pos of positions) {
+        this.pendingCulling.set(pos.toArray().join(","), pos.clone());
+        for (const offset of CUBE_FACE_OFFSETS) {
+          const neighbor = pos.clone().add(new Vector3(...offset));
+          this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
+        }
+      }
+      return this.culling ?? (this.culling = Promise.resolve().then(async () => {
+        try {
+          while (this.pendingCulling.size) {
+            const batch = [...this.pendingCulling.values()];
+            this.pendingCulling.clear();
+            for (const pos of batch) {
+              const block = this.getBlockAt(pos)?.object;
+              if (!block) continue;
+              let mask = 0;
+              for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
+                if (this.getBlockAt(pos.clone().add(new Vector3(...offset)))?.object.isOccluding) {
+                  mask |= 1 << face;
+                }
+              }
+              await block.setCullMask(mask);
+            }
+          }
+        } finally {
+          this.culling = void 0;
+        }
+      }));
     }
     getOrCreateChunkAt(pos) {
       const key = this.worldPosToChunkKey(pos);
       let chunk = this._chunks.get(key);
       if (typeof chunk === "undefined") {
-        chunk = new Chunk(this.scene, Math.floor(pos.x / 16), Math.floor(pos.y / 16), Math.floor(pos.z / 16));
+        chunk = new Chunk(
+          this.scene,
+          Math.floor(pos.x / 16),
+          Math.floor(pos.y / 16),
+          Math.floor(pos.z / 16),
+          (positions) => this.updateCulling(positions)
+        );
         this._chunks.set(key, chunk);
       }
       return chunk;
@@ -87741,7 +87900,8 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
 
   // src/world/Chunk.ts
   var Chunk = class _Chunk {
-    constructor(scene, x4, y5, z4) {
+    constructor(scene, x4, y5, z4, onBlocksChanged) {
+      this.onBlocksChanged = onBlocksChanged;
       this.data = new ChunkData();
       this.renderedBlocks = /* @__PURE__ */ new Map();
       this.scene = scene;
@@ -87784,10 +87944,10 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       const readBlock = this.data.snapshot(index);
       this.renderedBlocks.get(index)?.object.removeFromScene();
       this.renderedBlocks.delete(index);
-      if (!readBlock) return void 0;
-      const stored = readBlock();
       let object;
       try {
+        if (!readBlock) return void 0;
+        const stored = readBlock();
         const blockState = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
         if (!blockState) {
           this.data.set(index, void 0);
@@ -87809,12 +87969,18 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         this.data.set(index, void 0);
         object?.removeFromScene();
         throw error;
+      } finally {
+        await this.onBlocksChanged?.([worldPos]);
       }
     }
     async clear() {
+      const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
+        new Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      ));
       for (const info of this.renderedBlocks.values()) info.object.removeFromScene();
       this.renderedBlocks.clear();
       this.data.clear();
+      await this.onBlocksChanged?.(positions);
     }
     async dispose() {
       await this.clear();