fix: fix a few minor bugs

Author: me4502

scripts/generateTransparentList.js

@@ -19,6 +19,10 @@ async function doTheFilter() {
     const transparent = data
         .filter(bl => bl.material.opaque === false || bl.id.includes('door'))
         .map(bl => bl.id.replace('minecraft:', ''));
+
+    // MC has renamed this to short_grass; it's common enough to special case for old schematics.
+    transparent.push('grass');
+
     await Promise.all([
         writeFile(
             new URL('../src/renderer/nonOccluding.json', import.meta.url),

src/renderer/model/loader.ts

@@ -208,21 +208,20 @@ export function getModelLoader(resourceLoader: ResourceLoader): ModelLoader {
         const weightedRandomIndex = (
             options: BlockModelData['models'][number]['options']
         ) => {
-            const weights = [];
-
+            let totalWeight = 0;
             for (let i = 0; i < options.length; i++) {
-                weights[i] = options[i].weight + (weights[i - 1] || 0);
+                totalWeight += options[i].weight;
             }
 
-            const random = Math.random() * weights[weights.length - 1];
-
-            for (let i = 0; i < weights.length; i++) {
-                if (weights[i] > random) {
+            let random = Math.random() * totalWeight;
+            for (let i = 0; i < options.length; i++) {
+                random -= options[i].weight;
+                if (random < 0) {
                     return i;
                 }
             }
 
-            return weights.length - 1;
+            return options.length - 1;
         };
 
         let name = data.name;
@@ -242,9 +241,17 @@ export function getModelLoader(resourceLoader: ResourceLoader): ModelLoader {
         scene: Scene
     ) => {
         if (modelCache.has(data.name)) {
-            return modelCache
-                .get(data.name)
-                .map((mesh, i) => mesh.createInstance(`${data.name}-${i}`));
+            const cachedGroup = modelCache.get(data.name);
+            const instances = new Array<InstancedMesh>(cachedGroup.length);
+            const instanceNamePrefix = `${data.name}-`;
+
+            for (let i = 0; i < cachedGroup.length; i++) {
+                instances[i] = cachedGroup[i].createInstance(
+                    instanceNamePrefix + i
+                );
+            }
+
+            return instances;
         }
 
         const group: Mesh[] = [];
@@ -490,7 +497,13 @@ export function getModelLoader(resourceLoader: ResourceLoader): ModelLoader {
             mesh.isVisible = false;
         }
         modelCache.set(data.name, group);
-        return group.map((mesh, i) => mesh.createInstance(`${data.name}-${i}`));
+
+        const instances = new Array<InstancedMesh>(group.length);
+        const instanceNamePrefix = `${data.name}-`;
+        for (let i = 0; i < group.length; i++) {
+            instances[i] = group[i].createInstance(instanceNamePrefix + i);
+        }
+        return instances;
     };
 
     return {

src/renderer/renderer.ts

@@ -30,6 +30,26 @@ const CASSETTE_DECK_URL = `https://services.enginehub.org/cassette-deck/minecraf
 const URL_1_13 =
     'https://launcher.mojang.com/v1/objects/c0b970952cdd279912da384cdbfc0c26e6c6090b/client.jar';
 
+function blockKey(block: Block): string {
+    const props = block.properties ?? {};
+    const keys = Object.keys(props);
+    if (keys.length === 0) {
+        return block.type;
+    }
+
+    keys.sort();
+    let out = block.type + '[';
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (i > 0) {
+            out += ',';
+        }
+        out += key + '=' + String(props[key]);
+    }
+    out += ']';
+    return out;
+}
+
 async function getClientJarUrlDefault({
     dataVersion,
     corsBypassUrl,
@@ -88,9 +108,8 @@ export async function renderSchematic(
 
     scene.ambientColor = new Color3(0.5, 0.5, 0.5);
     if (backgroundColor !== 'transparent') {
-        scene.clearColor = Color4.FromHexString(
-            `#${backgroundColor.toString(16)}FF`
-        );
+        const hex = backgroundColor.toString(16).padStart(6, '0');
+        scene.clearColor = Color4.FromHexString(`#${hex}FF`);
     } else {
         scene.clearColor = new Color4(0, 0, 0, 0);
     }
@@ -142,7 +161,7 @@ export async function renderSchematic(
     ]);
     const modelLoader = getModelLoader(resourceLoader);
 
-    const blockModelLookup: Map<Block, BlockModelData> = new Map();
+    const blockModelLookup: Map<string, BlockModelData> = new Map();
 
     for (const block of loadedSchematic.blockTypes) {
         if (INVISIBLE_BLOCKS.has(block.type)) {
@@ -159,11 +178,17 @@ export async function renderSchematic(
             continue;
         }
 
-        blockModelLookup.set(block, blockModelData);
+        blockModelLookup.set(blockKey(block), blockModelData);
     }
 
     Mesh.INSTANCEDMESH_SORT_TRANSPARENT = true;
 
+    const worldXBase = -worldWidth / 2 + 0.5;
+    const worldYBase = -worldHeight / 2 + 0.5;
+    const worldZBase = -worldLength / 2 + 0.5;
+
+    const neighborPos = { x: 0, y: 0, z: 0 };
+
     scene.blockMaterialDirtyMechanism = true;
     for (const pos of loadedSchematic) {
         const { x, y, z } = pos;
@@ -173,7 +198,7 @@ export async function renderSchematic(
             continue;
         }
 
-        const modelData = blockModelLookup.get(block);
+        const modelData = blockModelLookup.get(blockKey(block));
         if (!modelData) {
             continue;
         }
@@ -182,11 +207,10 @@ export async function renderSchematic(
 
         for (const face of POSSIBLE_FACES) {
             const faceOffset = faceToFacingVector(face);
-            const offBlock = loadedSchematic.getBlock({
-                x: x + faceOffset[0],
-                y: y + faceOffset[1],
-                z: z + faceOffset[2],
-            });
+            neighborPos.x = x + faceOffset[0];
+            neighborPos.y = y + faceOffset[1];
+            neighborPos.z = z + faceOffset[2];
+            const offBlock = loadedSchematic.getBlock(neighborPos);
 
             if (!offBlock || NON_OCCLUDING_BLOCKS.has(offBlock.type)) {
                 anyVisible = true;
@@ -206,12 +230,10 @@ export async function renderSchematic(
                 continue;
             }
 
-            mesh.position.x += -worldWidth / 2 + x + 0.5;
-            mesh.position.y += -worldHeight / 2 + y + 0.5;
-            mesh.position.z += -worldLength / 2 + z + 0.5;
+            mesh.position.x += worldXBase + x;
+            mesh.position.y += worldYBase + y;
+            mesh.position.z += worldZBase + z;
             mesh.freezeWorldMatrix();
-
-            scene.addMesh(mesh);
         }
     }
     scene.blockMaterialDirtyMechanism = false;
@@ -254,8 +276,10 @@ export async function renderSchematic(
             engine.setSize(width, height);
         },
         destroy() {
-            engine.dispose();
             hasDestroyed = true;
+            engine.stopRenderLoop(render);
+            scene.dispose();
+            engine.dispose();
         },
         render,
         getEngine(): Engine {