minecraft-renderer 0.1.42 → 0.1.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/lib/worldrendererCommon.ts

@@ -628,6 +628,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       worldMinY: this.worldMinYRender,
       worldMaxY: this.worldMinYRender + this.worldSizeParams.worldHeight,
       disableConversionCache: this.worldRendererConfig.disableMesherConversionCache,
+      computeWireframeEdges: this.worldRendererConfig.futuristicReveal === true,
     }
   }
 

package/src/mesher-legacy/mesher.ts

@@ -1,7 +1,7 @@
 //@ts-nocheck
 import { Vec3 } from 'vec3'
 import { World } from '../mesher-shared/world'
-import { getSectionGeometry, setBlockStatesData as setMesherData } from '../mesher-shared/models'
+import { getSectionGeometry, setBlockStatesData as setMesherData, computeWireframeEdgesJS } from '../mesher-shared/models'
 import { BlockStateModelInfo } from '../mesher-shared/shared'
 import { handleGetHeightmap, EMPTY_COLUMN_HEIGHTMAP_SENTINEL } from '../mesher-shared/computeHeightmap'
 
@@ -208,7 +208,16 @@ setInterval(() => {
     if (chunk?.getSection(new Vec3(x, y, z))) {
       const start = performance.now()
       const geometry = getSectionGeometry(x, y, z, world)
+      if (geometry.positions.length > 0 && geometry.indices.length > 0 && world.config.computeWireframeEdges) {
+        const wireframeF32 = computeWireframeEdgesJS(geometry.positions as number[], geometry.indices as number[])
+        if (wireframeF32.length > 0) {
+          geometry.wireframePositions = wireframeF32
+        }
+      }
       const transferable = [geometry.positions?.buffer, geometry.normals?.buffer, geometry.colors?.buffer, geometry.uvs?.buffer].filter(Boolean)
+      if (geometry.wireframePositions) {
+        transferable.push(geometry.wireframePositions.buffer)
+      }
       //@ts-expect-error
       postMessage({ type: 'geometry', key, geometry, workerIndex }, transferable)
       processTime = performance.now() - start

package/src/mesher-shared/models.ts

@@ -794,3 +794,44 @@ export const setBlockStatesData = (blockstatesModels, blocksAtlas: any, _needTil
     }
   }
 }
+
+export function computeWireframeEdgesJS(positions: Float32Array | number[], indices: Uint32Array | Uint16Array | number[]): Float32Array {
+  const pos = positions instanceof Float32Array ? positions : new Float32Array(positions as number[])
+  const idx = indices instanceof Uint32Array ? indices : (indices instanceof Uint16Array ? new Uint32Array(indices) : new Uint32Array(indices as number[]))
+
+  const linePositions: number[] = []
+  const edgeSet = new Set<number>()
+
+  for (let i = 0; i < idx.length; i += 3) {
+    const i0 = idx[i]!
+    const i1 = idx[i + 1]!
+    const i2 = idx[i + 2]!
+
+    addEdgeJS(pos, i0, i1, linePositions, edgeSet)
+    addEdgeJS(pos, i1, i2, linePositions, edgeSet)
+    addEdgeJS(pos, i2, i0, linePositions, edgeSet)
+  }
+
+  return new Float32Array(linePositions)
+}
+
+function addEdgeJS(
+  positions: Float32Array,
+  i0: number,
+  i1: number,
+  linePositions: number[],
+  edgeSet: Set<number>
+): void {
+  const minI = i0 < i1 ? i0 : i1
+  const maxI = i0 < i1 ? i1 : i0
+  // Pack two indices into a single number (safe while indices < 2^24 — far above per-section vertex counts).
+  const key = minI * 0x1000000 + maxI
+
+  if (edgeSet.has(key)) return
+  edgeSet.add(key)
+
+  linePositions.push(
+    positions[i0 * 3]!, positions[i0 * 3 + 1]!, positions[i0 * 3 + 2]!,
+    positions[i1 * 3]!, positions[i1 * 3 + 1]!, positions[i1 * 3 + 2]!
+  )
+}

package/src/mesher-shared/shared.ts

@@ -19,6 +19,7 @@ export const defaultMesherConfig = {
   clipWorldBelowY: undefined as undefined | number,
   disableBlockEntityTextures: false,
   disableConversionCache: false,
+  computeWireframeEdges: false,
 }
 
 export type CustomBlockModels = {
@@ -60,6 +61,7 @@ export type MesherGeometryOutput = {
   // isFull: boolean
   hadErrors: boolean
   blocksCount: number
+  wireframePositions?: Float32Array
   customBlockModels?: CustomBlockModels
 }
 

package/src/three/modules/sciFiWorldReveal.ts

@@ -433,6 +433,12 @@ export class SciFiWorldRevealModule implements RendererModuleController {
    * Create wireframe geometry from mesh geometry
    */
   private createWireframeGeometry(geometry: MesherGeometryOutput): THREE.BufferGeometry {
+    if (geometry.wireframePositions && geometry.wireframePositions.length > 0) {
+      const wireframeGeom = new THREE.BufferGeometry()
+      wireframeGeom.setAttribute('position', new THREE.Float32BufferAttribute(geometry.wireframePositions, 3))
+      return wireframeGeom
+    }
+
     const positions = geometry.positions as Float32Array
     const indices = geometry.indices as Uint32Array | Uint16Array
 

package/src/three/worldRendererThree.ts

@@ -909,7 +909,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