minecraft-renderer 0.1.42 → 0.1.44

package/src/three/worldRendererThree.ts

@@ -9,7 +9,7 @@ import { renderSign } from '../sign-renderer'
 import { DisplayWorldOptions, GraphicsInitOptions } from '../graphicsBackend/types'
 import { chunkPos, sectionPos } from '../lib/simpleUtils'
 import { WorldRendererCommon } from '../lib/worldrendererCommon'
-import { addNewStat } from '../lib/ui/newStats'
+import { addNewStat, MC_RENDERER_DEBUG_OVERLAY_CLASS } from '../lib/ui/newStats'
 import { MesherGeometryOutput } from '../mesher-shared/shared'
 import { ItemSpecificContextProperties } from '../playerState/types'
 import { setBlockPosition } from '../mesher-shared/standaloneRenderer'
@@ -387,7 +387,7 @@ export class WorldRendererThree extends WorldRendererCommon {
         if ((prop === 'x' || prop === 'y' || prop === 'z') && typeof value === 'number' && Math.abs(value) > WORLD_COORD_THRESHOLD) {
           warnOnce()
         }
-        ;(target as any)[prop] = value
+        ; (target as any)[prop] = value
         return true
       },
       get(target, prop, receiver) {
@@ -701,22 +701,19 @@ export class WorldRendererThree extends WorldRendererCommon {
   addDebugOverlay() {
     if (this.debugOverlayAdded) return
     this.debugOverlayAdded = true
-    const pane = addNewStat('debug-overlay')
+    const pane = addNewStat('debug-overlay', 80, 0, undefined, { className: MC_RENDERER_DEBUG_OVERLAY_CLASS })
     setInterval(() => {
       pane.setVisibility(this.displayAdvancedStats)
       if (this.displayAdvancedStats) {
-        const formatBigNumber = (num: number) => {
-          return new Intl.NumberFormat('en-US', {}).format(num)
-        }
+        const formatFull = (num: number) => new Intl.NumberFormat('en-US', {}).format(num)
+        const formatCompact = (num: number) => new Intl.NumberFormat('en-US', { notation: 'compact', maximumFractionDigits: 1 }).format(num)
         let text = ''
-        text += `C: ${formatBigNumber(this.renderer.info.render.calls)} `
-        text += `TR: ${formatBigNumber(this.renderer.info.render.triangles)} `
-        text += `TE: ${formatBigNumber(this.renderer.info.memory.textures)} `
-        text += `F: ${formatBigNumber(this.tilesRendered)} `
-        text += `B: ${formatBigNumber(this.blocksRendered)} `
+        text += `TE: ${formatFull(this.renderer.info.memory.textures)} `
+        text += `F: ${formatCompact(this.tilesRendered)} `
+        text += `B: ${formatCompact(this.blocksRendered)} `
         text += `MEM: ${this.chunkMeshManager.getEstimatedMemoryUsage().total} `
         const poolStats = this.chunkMeshManager.getStats()
-        text += `POOL: ${poolStats.activeCount}/${poolStats.poolSize} HR: ${poolStats.hitRate}`
+        text += `POOL: ${poolStats.activeCount}/${poolStats.poolSize}`
         pane.updateText(text)
         this.backendInfoReport = text
       }
@@ -909,7 +906,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     const yOffset = this.playerStateReactive.eyeHeight
 
     this.updateCamera(pos?.offset(0, yOffset, 0) ?? null, yaw, pitch)
-    this.media.tryIntersectMedia()
+    // this.media.tryIntersectMedia()
     this.updateCameraSectionPos()
   }
 

package/src/wasm-mesher/runtime-build/wasm_mesher.d.ts

@@ -2,6 +2,29 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * Compute wireframe edge positions from a triangle mesh.
+ *
+ * Takes flat position and index arrays from an assembled mesh and returns a
+ * flat array of line-segment positions (x1,y1,z1,x2,y2,z2, ...) representing
+ * the unique edges of the mesh. Edge deduplication uses a `HashSet<(u32,u32)>`
+ * keyed on (min_vertex_index, max_vertex_index).
+ *
+ * `positions` — flat `Float32Array` of vertex positions (3 floats per vertex).
+ * `indices`  — flat `Uint32Array` of triangle indices (3 indices per triangle).
+ *              For 16-bit index arrays, prefer [`compute_wireframe_edges_u16`]
+ *              to avoid an extra JS-side `Uint32Array` allocation.
+ */
+export function computeWireframeEdges(positions: Float32Array, indices: Uint32Array): Float32Array;
+
+/**
+ * Same as [`compute_wireframe_edges`] but accepts a `Uint16Array` of indices.
+ *
+ * Avoids the JS-side `new Uint32Array(uint16)` allocation when the assembled
+ * section uses 16-bit indices (typical for sections with < 65k vertices).
+ */
+export function computeWireframeEdgesU16(positions: Float32Array, indices: Uint16Array): Float32Array;
+
 /**
  * VITALY's path: parse 1.18+ dump + light → run the mesher → return ONLY the final
  * geometry. Avoids marshalling the intermediate ~300KB block_states/biomes/lights
@@ -218,6 +241,8 @@ export interface InitOutput {
   readonly generateGeometryFromParsedV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number) => any;
   readonly generateGeometryFromMapChunkV18PlusMulti: (a: any, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number) => any;
   readonly generateGeometryFromParsedV16V17Multi: (a: any, b: number, c: number, d: number, e: number, f: number, g: any, h: number, i: any, j: any, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => any;
+  readonly computeWireframeEdges: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly computeWireframeEdgesU16: (a: number, b: number, c: number, d: number) => [number, number];
   readonly parseUpdateLightV17: (a: number, b: number, c: number) => any;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

package/src/wasm-mesher/runtime-build/wasm_mesher.js

@@ -71,6 +71,11 @@ function debugString(val) {
     return className;
 }
 
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayI32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
@@ -94,6 +99,14 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
 let cachedInt32ArrayMemory0 = null;
 function getInt32ArrayMemory0() {
     if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
@@ -161,6 +174,13 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -227,6 +247,53 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
+/**
+ * Compute wireframe edge positions from a triangle mesh.
+ *
+ * Takes flat position and index arrays from an assembled mesh and returns a
+ * flat array of line-segment positions (x1,y1,z1,x2,y2,z2, ...) representing
+ * the unique edges of the mesh. Edge deduplication uses a `HashSet<(u32,u32)>`
+ * keyed on (min_vertex_index, max_vertex_index).
+ *
+ * `positions` — flat `Float32Array` of vertex positions (3 floats per vertex).
+ * `indices`  — flat `Uint32Array` of triangle indices (3 indices per triangle).
+ *              For 16-bit index arrays, prefer [`compute_wireframe_edges_u16`]
+ *              to avoid an extra JS-side `Uint32Array` allocation.
+ * @param {Float32Array} positions
+ * @param {Uint32Array} indices
+ * @returns {Float32Array}
+ */
+export function computeWireframeEdges(positions, indices) {
+    const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(indices, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.computeWireframeEdges(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
+/**
+ * Same as [`compute_wireframe_edges`] but accepts a `Uint16Array` of indices.
+ *
+ * Avoids the JS-side `new Uint32Array(uint16)` allocation when the assembled
+ * section uses 16-bit indices (typical for sections with < 65k vertices).
+ * @param {Float32Array} positions
+ * @param {Uint16Array} indices
+ * @returns {Float32Array}
+ */
+export function computeWireframeEdgesU16(positions, indices) {
+    const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray16ToWasm0(indices, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.computeWireframeEdgesU16(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v3;
+}
+
 /**
  * VITALY's path: parse 1.18+ dump + light → run the mesher → return ONLY the final
  * geometry. Avoids marshalling the intermediate ~300KB block_states/biomes/lights
@@ -1001,6 +1068,7 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
     cachedInt32ArrayMemory0 = null;
     cachedUint16ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;

package/src/wasm-mesher/runtime-build/wasm_mesher_bg.wasm.d.ts

@@ -16,6 +16,8 @@ export const parseChunkSectionsV16V17: (a: number, b: number, c: number, d: numb
 export const generateGeometryFromParsedV16V17: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number) => any;
 export const generateGeometryFromMapChunkV18PlusMulti: (a: any, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number) => any;
 export const generateGeometryFromParsedV16V17Multi: (a: any, b: number, c: number, d: number, e: number, f: number, g: any, h: number, i: any, j: any, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number) => any;
+export const computeWireframeEdges: (a: number, b: number, c: number, d: number) => [number, number];
+export const computeWireframeEdgesU16: (a: number, b: number, c: number, d: number) => [number, number];
 export const parseUpdateLightV17: (a: number, b: number, c: number) => any;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

package/src/wasm-mesher/worker/mesherWasm.ts

@@ -1347,6 +1347,20 @@ function processColumnTick() {
             //@ts-ignore
             geometry.indices?.buffer,
           ].filter(Boolean)
+
+          if (exported.geometry.indices.length > 0 && config.computeWireframeEdges) {
+            try {
+              const wireframeF32 = geometry.indices instanceof Uint32Array
+                ? wasm!.computeWireframeEdges(geometry.positions as Float32Array, geometry.indices)
+                : wasm!.computeWireframeEdgesU16(geometry.positions as Float32Array, geometry.indices as Uint16Array)
+              if (wireframeF32.length > 0) {
+                geometry.wireframePositions = wireframeF32
+                transferable.push(wireframeF32.buffer)
+              }
+            } catch (err) {
+              // Fall through — sciFiWorldReveal will fall back to main-thread computation
+            }
+          }
         } else {
           geometry = makeEmptyColumnGeometry(sx, sy, sz, sectionHeight, false)
           // Still attach block entity metadata so the main thread sees

package/src/three/panorama.ts

@@ -1,312 +0,0 @@
-//@ts-nocheck
-import { join } from 'path'
-import * as THREE from 'three'
-import { getSyncWorld } from '../playground/shared'
-import { Vec3 } from 'vec3'
-import * as tweenJs from '@tweenjs/tween.js'
-import type { GraphicsInitOptions } from '../graphicsBackend/types'
-import { WorldRendererCommon } from '../lib/worldrendererCommon'
-import { defaultWorldRendererConfig, getDefaultRendererState } from '../graphicsBackend/config'
-import { ResourcesManager, ResourcesManagerTransferred } from '../resourcesManager/resourcesManager'
-import { getInitialPlayerStateRenderer } from '../graphicsBackend/playerState'
-import { loadThreeJsTextureFromUrl, loadThreeJsTextureFromUrlSync } from './threeJsUtils'
-import { WorldRendererThree } from './worldRendererThree'
-import { EntityMesh } from './entity/EntityMesh'
-import { DocumentRenderer } from './documentRenderer'
-import { PANORAMA_VERSION } from './panoramaShared'
-import { WorldView } from '../worldView'
-
-const date = new Date()
-const isChristmas = date.getMonth() === 11 && date.getDate() >= 24 && date.getDate() <= 26
-
-const panoramaFiles = [
-  'panorama_3.webp', // right (+x)
-  'panorama_1.webp', // left (-x)
-  'panorama_4.webp', // top (+y)
-  'panorama_5.webp', // bottom (-y)
-  'panorama_0.webp', // front (+z)
-  'panorama_2.webp', // back (-z)
-]
-
-export class PanoramaRenderer {
-  private readonly camera: THREE.PerspectiveCamera
-  private scene: THREE.Scene
-  private readonly ambientLight: THREE.AmbientLight
-  private readonly directionalLight: THREE.DirectionalLight
-  private panoramaGroup: THREE.Object3D | null = null
-  private time = 0
-  private readonly abortController = new AbortController()
-  private worldRenderer: WorldRendererCommon | WorldRendererThree | undefined
-  public WorldRendererClass = WorldRendererThree
-  public startTimes = new Map<THREE.MeshBasicMaterial, number>()
-
-  constructor(private readonly documentRenderer: DocumentRenderer, private readonly options: GraphicsInitOptions, private readonly doWorldBlocksPanorama = false) {
-    this.scene = new THREE.Scene()
-    // #324568
-    this.scene.background = new THREE.Color(0x32_45_68)
-
-    // Add ambient light
-    this.ambientLight = new THREE.AmbientLight(0xcc_cc_cc)
-    this.scene.add(this.ambientLight)
-
-    // Add directional light
-    this.directionalLight = new THREE.DirectionalLight(0xff_ff_ff, 0.5)
-    this.directionalLight.position.set(1, 1, 0.5).normalize()
-    this.directionalLight.castShadow = true
-    this.scene.add(this.directionalLight)
-
-    this.camera = new THREE.PerspectiveCamera(85, this.documentRenderer.canvas.width / this.documentRenderer.canvas.height, 0.05, 1000)
-    this.camera.position.set(0, 0, 0)
-    this.camera.rotation.set(0, 0, 0)
-  }
-
-  async start() {
-    if (this.doWorldBlocksPanorama) {
-      await this.worldBlocksPanorama()
-    } else {
-      this.addClassicPanorama()
-    }
-
-
-    this.documentRenderer.render = (sizeChanged = false) => {
-      if (sizeChanged) {
-        this.camera.aspect = this.documentRenderer.canvas.width / this.documentRenderer.canvas.height
-        this.camera.updateProjectionMatrix()
-      }
-      this.documentRenderer.renderer.render(this.scene, this.camera)
-    }
-  }
-
-  async debugImageInFrontOfCamera() {
-    const image = await loadThreeJsTextureFromUrl(join('background', 'panorama_0.webp'))
-    const mesh = new THREE.Mesh(new THREE.PlaneGeometry(1000, 1000), new THREE.MeshBasicMaterial({ map: image }))
-    mesh.position.set(0, 0, -500)
-    mesh.rotation.set(0, 0, 0)
-    this.scene.add(mesh)
-  }
-
-  addClassicPanorama() {
-    const panorGeo = new THREE.BoxGeometry(1000, 1000, 1000)
-    const panorMaterials = [] as THREE.MeshBasicMaterial[]
-    const fadeInDuration = 200
-
-    // void this.debugImageInFrontOfCamera()
-
-    for (const file of panoramaFiles) {
-      const load = async () => {
-        const { texture } = loadThreeJsTextureFromUrlSync(join('background', isChristmas ? 'christmas' : '', file))
-
-        // Instead of using repeat/offset to flip, we'll use the texture matrix
-        texture.matrixAutoUpdate = false
-        texture.matrix.set(
-          -1, 0, 1, 0, 1, 0, 0, 0, 1
-        )
-
-        texture.wrapS = THREE.ClampToEdgeWrapping
-        texture.wrapT = THREE.ClampToEdgeWrapping
-        texture.minFilter = THREE.LinearFilter
-        texture.magFilter = THREE.LinearFilter
-
-        const material = new THREE.MeshBasicMaterial({
-          map: texture,
-          transparent: true,
-          side: THREE.DoubleSide,
-          depthWrite: false,
-          opacity: 0 // Start with 0 opacity
-        })
-
-        // Start fade-in when texture is loaded
-        this.startTimes.set(material, Date.now())
-        panorMaterials.push(material)
-      }
-
-      void load()
-    }
-
-    const panoramaBox = new THREE.Mesh(panorGeo, panorMaterials)
-    panoramaBox.onBeforeRender = () => {
-      this.time += 0.01
-      panoramaBox.rotation.y = Math.PI + this.time * 0.01
-      panoramaBox.rotation.z = Math.sin(-this.time * 0.001) * 0.001
-
-      // Time-based fade in animation for each material
-      for (const material of panorMaterials) {
-        const startTime = this.startTimes.get(material)
-        if (startTime) {
-          const elapsed = Date.now() - startTime
-          const progress = Math.min(1, elapsed / fadeInDuration)
-          material.opacity = progress
-        }
-      }
-    }
-
-    const group = new THREE.Object3D()
-    group.add(panoramaBox)
-
-    if (!isChristmas) {
-      // Add entities
-      for (let i = 0; i < 20; i++) {
-        const m = new EntityMesh('1.16.4', 'squid').mesh
-        m.position.set(Math.random() * 30 - 15, Math.random() * 20 - 10, Math.random() * 10 - 17)
-        m.rotation.set(0, Math.PI + Math.random(), -Math.PI / 4, 'ZYX')
-        const v = Math.random() * 0.01
-        m.children[0].onBeforeRender = () => {
-          m.rotation.y += v
-          m.rotation.z = Math.cos(panoramaBox.rotation.y * 3) * Math.PI / 4 - Math.PI / 2
-        }
-        group.add(m)
-      }
-    }
-
-    this.scene.add(group)
-    this.panoramaGroup = group
-  }
-
-  async worldBlocksPanorama() {
-    const version = PANORAMA_VERSION
-
-    const fullResourceManager = new ResourcesManager()
-
-    fullResourceManager.currentConfig = { version, noInventoryGui: true, }
-    await fullResourceManager.updateAssetsData?.({})
-    if (this.abortController.signal.aborted) return
-    console.time('load panorama scene')
-    const world = getSyncWorld(version)
-    const PrismarineBlock = require('prismarine-block')
-    const Block = PrismarineBlock(version)
-    const mcData = (globalThis as any).mcData
-    const fullBlocks = mcData.blocksArray.filter(block => {
-      // if (block.name.includes('leaves')) return false
-      if (/* !block.name.includes('wool') &&  */!block.name.includes('stained_glass')/*  && !block.name.includes('terracotta') */) return false
-      const b = Block.fromStateId(block.defaultState, 0)
-      if (b.shapes?.length !== 1) return false
-      const shape = b.shapes[0]
-      return shape[0] === 0 && shape[1] === 0 && shape[2] === 0 && shape[3] === 1 && shape[4] === 1 && shape[5] === 1
-    })
-    const Z = -15
-    const sizeX = 100
-    const sizeY = 100
-    for (let x = -sizeX; x < sizeX; x++) {
-      for (let y = -sizeY; y < sizeY; y++) {
-        const block = fullBlocks[Math.floor(Math.random() * fullBlocks.length)]
-        world.setBlockStateId(new Vec3(x, y, Z), block.defaultState)
-      }
-    }
-    this.camera.updateProjectionMatrix()
-    this.camera.position.set(0.5, sizeY / 2 + 0.5, 0.5)
-    this.camera.rotation.set(0, 0, 0)
-    const initPos = new Vec3(...this.camera.position.toArray())
-    const worldView = new WorldView(world, 2, initPos)
-    // worldView.addWaitTime = 0
-    if (this.abortController.signal.aborted) return
-
-    this.worldRenderer = new this.WorldRendererClass(
-      this.documentRenderer.renderer,
-      this.options,
-      {
-        version,
-        worldView,
-        inWorldRenderingConfig: defaultWorldRendererConfig,
-        playerStateReactive: getInitialPlayerStateRenderer().reactive,
-        rendererState: getDefaultRendererState().reactive,
-        nonReactiveState: getDefaultRendererState().nonReactive,
-        resourcesManager: fullResourceManager as ResourcesManagerTransferred // todo use guard instead
-      }
-    )
-    if (this.worldRenderer instanceof WorldRendererThree) {
-      this.scene = this.worldRenderer.realScene
-    }
-    void worldView.init(initPos)
-
-    await this.worldRenderer.waitForChunksToRender()
-    if (this.abortController.signal.aborted) return
-    // add small camera rotation to side on mouse move depending on absolute position of the cursor
-    const { camera } = this
-    const initX = camera.position.x
-    const initY = camera.position.y
-    let prevTwin: tweenJs.Tween<THREE.Vector3> | undefined
-    document.body.addEventListener('pointermove', (e) => {
-      if (e.pointerType !== 'mouse') return
-      const pos = new THREE.Vector2(e.clientX, e.clientY)
-      const SCALE = 0.2
-      /* -0.5 - 0.5 */
-      const xRel = pos.x / window.innerWidth - 0.5
-      const yRel = -(pos.y / window.innerHeight - 0.5)
-      prevTwin?.stop()
-      const to = {
-        x: initX + (xRel * SCALE),
-        y: initY + (yRel * SCALE)
-      }
-      prevTwin = new tweenJs.Tween(camera.position).to(to, 0) // todo use the number depending on diff // todo use the number depending on diff
-      // prevTwin.easing(tweenJs.Easing.Exponential.InOut)
-      prevTwin.start()
-      camera.updateProjectionMatrix()
-    }, {
-      signal: this.abortController.signal
-    })
-
-    console.timeEnd('load panorama scene')
-  }
-
-  dispose() {
-    this.scene.clear()
-    this.worldRenderer?.destroy()
-    this.abortController.abort()
-  }
-}
-
-// export class ClassicPanoramaRenderer {
-//   panoramaGroup: THREE.Object3D
-
-//   constructor (private readonly backgroundFiles: string[], onRender: Array<(sizeChanged: boolean) => void>, addSquids = true) {
-//     const panorGeo = new THREE.BoxGeometry(1000, 1000, 1000)
-//     const loader = new THREE.TextureLoader()
-//     const panorMaterials = [] as THREE.MeshBasicMaterial[]
-
-//     for (const file of this.backgroundFiles) {
-//       const texture = loader.load(file)
-
-//       // Instead of using repeat/offset to flip, we'll use the texture matrix
-//       texture.matrixAutoUpdate = false
-//       texture.matrix.set(
-//         -1, 0, 1, 0, 1, 0, 0, 0, 1
-//       )
-
-//       texture.wrapS = THREE.ClampToEdgeWrapping // Changed from RepeatWrapping
-//       texture.wrapT = THREE.ClampToEdgeWrapping // Changed from RepeatWrapping
-//       texture.minFilter = THREE.LinearFilter
-//       texture.magFilter = THREE.LinearFilter
-
-//       panorMaterials.push(new THREE.MeshBasicMaterial({
-//         map: texture,
-//         transparent: true,
-//         side: THREE.DoubleSide,
-//         depthWrite: false,
-//       }))
-//     }
-
-//     const panoramaBox = new THREE.Mesh(panorGeo, panorMaterials)
-//     panoramaBox.onBeforeRender = () => {
-//     }
-
-//     const group = new THREE.Object3D()
-//     group.add(panoramaBox)
-
-//     if (addSquids) {
-//       // Add squids
-//       for (let i = 0; i < 20; i++) {
-//         const m = new EntityMesh('1.16.4', 'squid').mesh
-//         m.position.set(Math.random() * 30 - 15, Math.random() * 20 - 10, Math.random() * 10 - 17)
-//         m.rotation.set(0, Math.PI + Math.random(), -Math.PI / 4, 'ZYX')
-//         const v = Math.random() * 0.01
-//         onRender.push(() => {
-//           m.rotation.y += v
-//           m.rotation.z = Math.cos(panoramaBox.rotation.y * 3) * Math.PI / 4 - Math.PI / 2
-//         })
-//         group.add(m)
-//       }
-//     }
-
-//     this.panoramaGroup = group
-//   }
-// }

package/src/three/panoramaShared.ts

@@ -1,2 +0,0 @@
-//@ts-nocheck
-export const PANORAMA_VERSION = '1.21.4'