@divinevoxel/vlox 0.0.80 → 0.0.81

package/Tasks/Propagation/Illumanation/SunUpdate.js

@@ -1,117 +1,221 @@
 import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData";
 import { isLessThanForSunAdd, getMinusOneForSun, isLessThanForSunAddDown, getSunLightForUnderVoxel, removeSunLight, isLessThanForSunRemove, isGreaterOrEqualThanForSunRemove, sunLightCompareForDownSunRemove, } from "./CommonFunctions";
-const FloodOutPositions = [
-    [1, 0, 0],
-    [-1, 0, 0],
-    [0, 0, 1],
-    [0, 0, -1],
-    [0, 1, 0],
-];
 export function SunUpdate(tasks) {
     const queue = tasks.sun.update;
-    while (queue.length) {
-        const x = queue.shift();
-        const y = queue.shift();
-        const z = queue.shift();
-        const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    const sDataCursor = tasks.sDataCursor;
+    const nDataCursor = tasks.nDataCursor;
+    const bounds = tasks.bounds;
+    const sunFallOff = VoxelLightData.SunFallOffValue;
+    let queueIndex = 0;
+    while (queueIndex < queue.length) {
+        const x = queue[queueIndex++];
+        const y = queue[queueIndex++];
+        const z = queue[queueIndex++];
+        const voxel = sDataCursor.getVoxel(x, y, z);
         if (!voxel)
             continue;
         const sl = voxel.getLight();
         if (sl <= 0)
             continue;
-        for (let i = 0; i < 5; i++) {
-            const nx = FloodOutPositions[i][0] + x;
-            const ny = FloodOutPositions[i][1] + y;
-            const nz = FloodOutPositions[i][2] + z;
-            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
-                continue;
-            const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        let nx, ny, nz, nVoxel, nl;
+        nx = x + 1;
+        if (nDataCursor.inBounds(nx, y, z)) {
+            nVoxel = nDataCursor.getVoxel(nx, y, z);
             if (nVoxel) {
-                const nl = nVoxel.getLight();
-                if (nl > -1 && isLessThanForSunAdd(nl, sl, VoxelLightData.SunFallOffValue)) {
-                    queue.push(nx, ny, nz);
-                    nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                    queue.push(nx, y, z);
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
                 }
             }
         }
-        if (tasks.nDataCursor.inBounds(x, y - 1, z)) {
-            const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
+        nx = x - 1;
+        if (nDataCursor.inBounds(nx, y, z)) {
+            nVoxel = nDataCursor.getVoxel(nx, y, z);
             if (nVoxel) {
-                const nl = nVoxel.getLight();
-                if (nl > -1 && isLessThanForSunAddDown(nl, sl, VoxelLightData.SunFallOffValue)) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                    queue.push(nx, y, z);
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
+                }
+            }
+        }
+        nz = z + 1;
+        if (nDataCursor.inBounds(x, y, nz)) {
+            nVoxel = nDataCursor.getVoxel(x, y, nz);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                    queue.push(x, y, nz);
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
+                }
+            }
+        }
+        nz = z - 1;
+        if (nDataCursor.inBounds(x, y, nz)) {
+            nVoxel = nDataCursor.getVoxel(x, y, nz);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                    queue.push(x, y, nz);
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
+                }
+            }
+        }
+        ny = y + 1;
+        if (nDataCursor.inBounds(x, ny, z)) {
+            nVoxel = nDataCursor.getVoxel(x, ny, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                    queue.push(x, ny, z);
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
+                }
+            }
+        }
+        ny = y - 1;
+        if (nDataCursor.inBounds(x, ny, z)) {
+            nVoxel = nDataCursor.getVoxel(x, ny, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForSunAddDown(nl, sl, sunFallOff)) {
                     if (nVoxel.isAir()) {
-                        queue.push(x, y - 1, z);
-                        nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, VoxelLightData.SunFallOffValue));
+                        queue.push(x, ny, z);
+                        nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, sunFallOff));
                     }
-                    else {
-                        if (!nVoxel.isOpaque()) {
-                            queue.push(x, y - 1, z);
-                            nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
-                        }
+                    else if (!nVoxel.isOpaque()) {
+                        queue.push(x, ny, z);
+                        nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
                     }
                 }
             }
         }
-        tasks.bounds.updateDisplay(x, y, z);
+        bounds.updateDisplay(x, y, z);
     }
+    queue.length = 0;
 }
-export function SunRemove(tasks, clearUpdateMap = true) {
+export function SunRemove(tasks) {
     const remove = tasks.sun.remove;
     const update = tasks.sun.update;
     const removeMap = tasks.sun.removeMap;
     const updateMap = tasks.sun.updateMap;
-    while (remove.length) {
-        const x = remove.shift();
-        const y = remove.shift();
-        const z = remove.shift();
+    const sDataCursor = tasks.sDataCursor;
+    const nDataCursor = tasks.nDataCursor;
+    const bounds = tasks.bounds;
+    let removeIndex = 0;
+    while (removeIndex < remove.length) {
+        const x = remove[removeIndex++];
+        const y = remove[removeIndex++];
+        const z = remove[removeIndex++];
         if (removeMap.has(x, y, z))
             continue;
         removeMap.add(x, y, z);
-        const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+        const voxel = sDataCursor.getVoxel(x, y, z);
         if (!voxel)
             continue;
         const sl = voxel.getLight();
         if (sl <= 0)
             continue;
-        for (let i = 0; i < 5; i++) {
-            const nx = FloodOutPositions[i][0] + x;
-            const ny = FloodOutPositions[i][1] + y;
-            const nz = FloodOutPositions[i][2] + z;
-            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
-                continue;
-            const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        let nx, ny, nz, nVoxel, nl;
+        nx = x + 1;
+        if (nDataCursor.inBounds(nx, y, z)) {
+            nVoxel = nDataCursor.getVoxel(nx, y, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > 0) {
+                    if (isLessThanForSunRemove(nl, sl)) {
+                        remove.push(nx, y, z);
+                    }
+                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) && !updateMap.has(nx, y, z)) {
+                        updateMap.add(nx, y, z);
+                        update.push(nx, y, z);
+                    }
+                }
+            }
+        }
+        nx = x - 1;
+        if (nDataCursor.inBounds(nx, y, z)) {
+            nVoxel = nDataCursor.getVoxel(nx, y, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > 0) {
+                    if (isLessThanForSunRemove(nl, sl)) {
+                        remove.push(nx, y, z);
+                    }
+                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) && !updateMap.has(nx, y, z)) {
+                        updateMap.add(nx, y, z);
+                        update.push(nx, y, z);
+                    }
+                }
+            }
+        }
+        nz = z + 1;
+        if (nDataCursor.inBounds(x, y, nz)) {
+            nVoxel = nDataCursor.getVoxel(x, y, nz);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > 0) {
+                    if (isLessThanForSunRemove(nl, sl)) {
+                        remove.push(x, y, nz);
+                    }
+                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) && !updateMap.has(x, y, nz)) {
+                        updateMap.add(x, y, nz);
+                        update.push(x, y, nz);
+                    }
+                }
+            }
+        }
+        nz = z - 1;
+        if (nDataCursor.inBounds(x, y, nz)) {
+            nVoxel = nDataCursor.getVoxel(x, y, nz);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > 0) {
+                    if (isLessThanForSunRemove(nl, sl)) {
+                        remove.push(x, y, nz);
+                    }
+                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) && !updateMap.has(x, y, nz)) {
+                        updateMap.add(x, y, nz);
+                        update.push(x, y, nz);
+                    }
+                }
+            }
+        }
+        ny = y + 1;
+        if (nDataCursor.inBounds(x, ny, z)) {
+            nVoxel = nDataCursor.getVoxel(x, ny, z);
             if (nVoxel) {
-                const nl = nVoxel.getLight();
+                nl = nVoxel.getLight();
                 if (nl > 0) {
                     if (isLessThanForSunRemove(nl, sl)) {
-                        remove.push(nx, ny, nz);
+                        remove.push(x, ny, z);
                     }
-                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) &&
-                        !updateMap.has(nx, ny, nz)) {
-                        updateMap.add(nx, ny, nz);
-                        update.push(nx, ny, nz);
+                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) && !updateMap.has(x, ny, z)) {
+                        updateMap.add(x, ny, z);
+                        update.push(x, ny, z);
                     }
                 }
             }
         }
-        if (tasks.nDataCursor.inBounds(x, y - 1, z)) {
-            const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
+        ny = y - 1;
+        if (nDataCursor.inBounds(x, ny, z)) {
+            nVoxel = nDataCursor.getVoxel(x, ny, z);
             if (nVoxel) {
-                const nl = nVoxel.getLight();
+                nl = nVoxel.getLight();
                 if (nl > 0) {
                     if (sunLightCompareForDownSunRemove(nl, sl)) {
-                        remove.push(x, y - 1, z);
+                        remove.push(x, ny, z);
                     }
-                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) &&
-                        !updateMap.has(x, y - 1, z)) {
-                        updateMap.add(x, y - 1, z);
-                        update.push(x, y - 1, z);
+                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) && !updateMap.has(x, ny, z)) {
+                        updateMap.add(x, ny, z);
+                        update.push(x, ny, z);
                     }
                 }
             }
         }
-        tasks.bounds.updateDisplay(x, y, z);
+        bounds.updateDisplay(x, y, z);
         voxel.setLight(removeSunLight(sl));
     }
+    remove.length = 0;
     removeMap.clear();
 }

package/Tasks/Propagation/Illumanation/WorldSun.js

@@ -3,31 +3,33 @@ import { WorldSpaces } from "../../../World/WorldSpaces.js";
 import { SectorHeightMap } from "../../../World/Sector/SectorHeightMap.js";
 import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData.js";
 import { getMinusOneForSun, getSunLightForUnderVoxel, isLessThanForSunAddDown, isLessThanForSunAdd, } from "./CommonFunctions.js";
-const FloodOutPositions = [
-    [1, 0, 0],
-    [-1, 0, 0],
-    [0, 0, 1],
-    [0, 0, -1],
-    [0, 1, 0],
-];
 const queue = [];
 const lightData = new VoxelLightData();
 export function RunWorldSun(tasks) {
-    const [, cx, cy, cz] = tasks.origin;
-    const RmaxY = SectorHeightMap.getRelative(tasks.origin);
-    const AmaxY = SectorHeightMap.getAbsolute(...tasks.origin);
-    const maxX = cx + WorldSpaces.sector.bounds.x;
-    const maxY = cy + WorldSpaces.sector.bounds.y;
-    const maxZ = cz + WorldSpaces.sector.bounds.z;
-    const sectorCursor = tasks.nDataCursor.getSector(tasks.origin[1], tasks.origin[2], tasks.origin[3]);
+    const origin = tasks.origin;
+    const cx = origin[1];
+    const cy = origin[2];
+    const cz = origin[3];
+    const sectorBoundsX = WorldSpaces.sector.bounds.x;
+    const sectorBoundsY = WorldSpaces.sector.bounds.y;
+    const sectorBoundsZ = WorldSpaces.sector.bounds.z;
+    const sectionBoundsY = WorldSpaces.section.bounds.y;
+    const RmaxY = SectorHeightMap.getRelative(origin);
+    const AmaxY = SectorHeightMap.getAbsolute(origin[0], origin[1], origin[2], origin[3]);
+    const maxX = cx + sectorBoundsX;
+    const maxY = cy + sectorBoundsY;
+    const maxZ = cz + sectorBoundsZ;
+    const sectorCursor = tasks.nDataCursor.getSector(origin[1], origin[2], origin[3]);
     if (!sectorCursor) {
-        console.warn("Could not load sector when running world sun at ", tasks.origin.toString());
+        console.warn("Could not load sector when running world sun at ", origin.toString());
         return;
     }
     const minY = AmaxY - 1 < 0 ? 0 : AmaxY;
     const section = sectorCursor.getSection(cx, minY, cz);
-    const sectionY = section.getPosition()[1] + WorldSpaces.section.bounds.y;
-    //fill to relative max y
+    const sectionY = section.getPosition()[1] + sectionBoundsY;
+    const sunFallOff = VoxelLightData.SunFallOffValue;
+    const nDataCursor = tasks.nDataCursor;
+    const sDataCursor = tasks.sDataCursor;
     for (let iy = minY; iy < sectionY; iy++) {
         for (let ix = cx; ix < maxX; ix++) {
             for (let iz = cz; iz < maxZ; iz++) {
@@ -41,80 +43,114 @@ export function RunWorldSun(tasks) {
             }
         }
     }
-    //fill rest
-    for (let iy = sectionY; iy < maxY; iy += WorldSpaces.section.bounds.y) {
-        const section = sectorCursor.getSection(cx, iy, cz);
-        const length = section.light.length;
+    for (let iy = sectionY; iy < maxY; iy += sectionBoundsY) {
+        const sec = sectorCursor.getSection(cx, iy, cz);
+        const light = sec.light;
+        const length = light.length;
         for (let i = 0; i < length; i++) {
-            section.light[i] = lightData.setS(0xf, section.light[i]);
+            light[i] = lightData.setS(0xf, light[i]);
         }
     }
-    //accumulate
     const maxAcculamteY = AmaxY == RmaxY ? RmaxY + 1 : RmaxY;
-    let index = queue.length;
+    let queueIndex = 0;
+    queue.length = 0;
     for (let iy = minY; iy <= maxAcculamteY; iy++) {
         for (let ix = cx; ix < maxX; ix++) {
             for (let iz = cz; iz < maxZ; iz++) {
-                const l = sectorCursor.getVoxel(ix, iy, iz)?.getLight();
-                if (l && l < 0 && lightData.getS(l) != 0xf)
+                const voxel = sectorCursor.getVoxel(ix, iy, iz);
+                if (!voxel)
+                    continue;
+                const l = voxel.getLight();
+                if (l < 0 || lightData.getS(l) != 0xf)
                     continue;
                 for (let i = 0; i < CardinalNeighbors3D.length; i++) {
                     const n = CardinalNeighbors3D[i];
                     const nx = ix + n[0];
                     const ny = iy + n[1];
                     const nz = iz + n[2];
-                    const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+                    const nVoxel = nDataCursor.getVoxel(nx, ny, nz);
                     if (!nVoxel)
                         continue;
                     const nl = nVoxel.getLight();
                     if (nl > -1 && lightData.getS(nl) < 0xf) {
-                        queue[index++] = ix;
-                        queue[index++] = iy;
-                        queue[index++] = iz;
+                        queue.push(ix, iy, iz);
                         break;
                     }
                 }
             }
         }
     }
-    //flood
-    while (queue.length) {
-        const x = queue.shift();
-        const y = queue.shift();
-        const z = queue.shift();
-        const sl = tasks.sDataCursor.getVoxel(x, y, z)?.getLight();
-        if (!sl || sl < 0)
+    while (queueIndex < queue.length) {
+        const x = queue[queueIndex++];
+        const y = queue[queueIndex++];
+        const z = queue[queueIndex++];
+        const voxel = sDataCursor.getVoxel(x, y, z);
+        if (!voxel)
             continue;
-        for (let i = 0; i < 5; i++) {
-            const nx = x + FloodOutPositions[i][0];
-            const ny = y + FloodOutPositions[i][1];
-            const nz = z + FloodOutPositions[i][2];
-            const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
-            if (nVoxel) {
-                const nl = nVoxel.getLight();
-                if (nl > -1 &&
-                    isLessThanForSunAdd(nl, sl, VoxelLightData.SunFallOffValue)) {
-                    queue.push(nx, ny, nz);
-                    nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
-                }
+        const sl = voxel.getLight();
+        if (sl < 0)
+            continue;
+        let nx, ny, nz, nVoxel, nl;
+        nx = x + 1;
+        nVoxel = nDataCursor.getVoxel(nx, y, z);
+        if (nVoxel) {
+            nl = nVoxel.getLight();
+            if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                queue.push(nx, y, z);
+                nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
+            }
+        }
+        nx = x - 1;
+        nVoxel = nDataCursor.getVoxel(nx, y, z);
+        if (nVoxel) {
+            nl = nVoxel.getLight();
+            if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                queue.push(nx, y, z);
+                nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
             }
         }
-        const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
+        nz = z + 1;
+        nVoxel = nDataCursor.getVoxel(x, y, nz);
         if (nVoxel) {
-            const nl = nVoxel.getLight();
-            if (nl > -1 &&
-                isLessThanForSunAddDown(nl, sl, VoxelLightData.SunFallOffValue)) {
+            nl = nVoxel.getLight();
+            if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                queue.push(x, y, nz);
+                nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
+            }
+        }
+        nz = z - 1;
+        nVoxel = nDataCursor.getVoxel(x, y, nz);
+        if (nVoxel) {
+            nl = nVoxel.getLight();
+            if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                queue.push(x, y, nz);
+                nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
+            }
+        }
+        ny = y + 1;
+        nVoxel = nDataCursor.getVoxel(x, ny, z);
+        if (nVoxel) {
+            nl = nVoxel.getLight();
+            if (nl > -1 && isLessThanForSunAdd(nl, sl, sunFallOff)) {
+                queue.push(x, ny, z);
+                nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
+            }
+        }
+        ny = y - 1;
+        nVoxel = nDataCursor.getVoxel(x, ny, z);
+        if (nVoxel) {
+            nl = nVoxel.getLight();
+            if (nl > -1 && isLessThanForSunAddDown(nl, sl, sunFallOff)) {
                 if (nVoxel.isAir()) {
-                    queue.push(x, y - 1, z);
-                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, VoxelLightData.SunFallOffValue));
+                    queue.push(x, ny, z);
+                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, sunFallOff));
                 }
-                else {
-                    if (!nVoxel.isOpaque()) {
-                        queue.push(x, y - 1, z);
-                        nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
-                    }
+                else if (!nVoxel.isOpaque()) {
+                    queue.push(x, ny, z);
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, sunFallOff));
                 }
             }
         }
     }
+    queue.length = 0;
 }

package/Tasks/WorldGeneration/WorldGenBrush.d.ts

@@ -1,11 +1,13 @@
 import type { Vec3Array } from "@amodx/math";
 import { BrushTool } from "../../Tools/Brush/Brush.js";
 import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { RawVoxelData } from "Voxels/index.js";
 export declare class WorldGenBrush extends BrushTool {
     constructor();
     requestsId: "";
     tasks: VoxelUpdateTask;
     start(dimension: number, x: number, y: number, z: number): this;
+    paintRaw(raw: RawVoxelData): this;
     paint(): this;
     getUpdatedSections(): Vec3Array[];
     update(): false | undefined;

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -22,6 +22,37 @@ export class WorldGenBrush extends BrushTool {
         this.z = z;
         return this;
     }
+    paintRaw(raw) {
+        let voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
+        if (!voxel) {
+            if (this.requestsId != "") {
+                WorldGenRegister.addToRequest(this.requestsId, [this.dimension, this.x, this.y, this.z], this.voxelCursor.getRaw());
+                return this;
+            }
+            throw new Error(`Tried painting in an unloaded location ${[
+                this.dimension,
+                this.x,
+                this.y,
+                this.z,
+            ].toString()}`);
+        }
+        const sl = voxel.getLight();
+        if (sl > 0 || !voxel.isAir()) {
+            this._erase();
+            voxel.setLight(sl < 0 ? 0 : sl);
+            if (lightData.hasRGBLight(sl)) {
+                this.tasks.rgb.remove.push(this.x, this.y, this.z);
+                RGBRemove(this.tasks);
+            }
+            if (lightData.hasSunLight(sl)) {
+                this.tasks.sun.remove.push(this.x, this.y, this.z);
+                SunRemove(this.tasks);
+            }
+        }
+        this._paintRaw(raw);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
+        return this;
+    }
     paint() {
         let voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         if (!voxel) {

package/Templates/Archive/ArchivedVoxelTemplate.js

@@ -45,7 +45,7 @@ export class ArchivedVoxelTemplate {
     }
     getSecondary(index) {
         const id = this.getId(index);
-        const trueId = VoxelLUT.voxels[id][0];
+        const trueId = VoxelLUT.voxelIdToTrueId[id];
         if (VoxelTagsRegister.VoxelTags[trueId]["dve_can_have_secondary"]) {
             return VoxelLUT.getVoxelIdFromString(...this.voxelPalette.getVoxelData(this.secondaryPalette.getValue(this.secondary.getValue(index))));
         }

package/Templates/Archive/Functions/CreateArchivedTemplate.js

@@ -44,7 +44,7 @@ export default function CreateArchivedTemplate(dataCursor, bounds) {
                     ? levelPalette.register(level)
                     : levelPalette.getId(level);
                 let voxelSecondary = 0;
-                if (VoxelTagsRegister.VoxelTags[VoxelLUT.voxels[rawData[0]][0]]["dve_can_have_secondary"]) {
+                if (VoxelTagsRegister.VoxelTags[VoxelLUT.voxelIdToTrueId[rawData[0]]]["dve_can_have_secondary"]) {
                     voxelSecondary = voxelPalette.register(rawData[3]);
                     if (!secondaryPalette.isRegistered(voxelSecondary))
                         secondaryPalette.register(voxelSecondary);

package/Templates/Archive/Functions/CreateArchivedTemplateFromFull.d.ts

@@ -0,0 +1,6 @@
+import { ArchivedVoxelTemplate } from "../ArchivedVoxelTemplate";
+import { FullVoxelTemplateData } from "../../Full/FullVoxelTemplate.types";
+/**
+ * Converts a FullVoxelTemplateData into an ArchivedVoxelTemplate.
+ */
+export default function CreateArchivedTemplateFromFull(fullData: FullVoxelTemplateData): ArchivedVoxelTemplate;