@divinevoxel/vlox 0.0.74 → 0.0.75

package/Tasks/Propagation/Explosion/ExplosionManager.js

@@ -1,116 +0,0 @@
-//data
-import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors.js";
-//objects
-//functions
-import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
-import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate.js";
-import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate.js";
-import { VisitedMap } from "../../../Util/VisistedMap";
-import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData.js";
-const lightData = new VoxelLightData();
-export const ExplosionManager = {
-    runExplosion(tasks, radius) {
-        const [dimension, sx, sy, sz] = tasks.origin;
-        //   FlowManager.setDimension(dimension);
-        const queue = [];
-        const map = new VisitedMap();
-        queue.push([sx, sy, sz]);
-        while (queue.length) {
-            const node = queue.shift();
-            if (!node)
-                break;
-            const x = node[0];
-            const y = node[1];
-            const z = node[2];
-            if (!map.inMap(x + 1, y, z)) {
-                if (tasks.sDataCursor.getVoxel(x + 1, y, z)) {
-                    const d = Distance3D(sx, sy, sz, x + 1, y, z);
-                    if (d <= radius) {
-                        queue.push([x + 1, y, z]);
-                    }
-                    map.add(x + 1, y, z);
-                }
-            }
-            if (!map.inMap(x - 1, y, z)) {
-                if (tasks.sDataCursor.getVoxel(x - 1, y, z)) {
-                    const d = Distance3D(sx, sy, sz, x - 1, y, z);
-                    if (d <= radius) {
-                        queue.push([x - 1, y, z]);
-                    }
-                }
-                map.add(x - 1, y, z);
-            }
-            if (!map.inMap(x, y, z + 1)) {
-                if (tasks.sDataCursor.getVoxel(x, y, z + 1)) {
-                    const d = Distance3D(sx, sy, sz, x, y, z + 1);
-                    if (d <= radius) {
-                        queue.push([x, y, z + 1]);
-                    }
-                }
-                map.add(x, y, z + 1);
-            }
-            if (!map.inMap(x, y, z - 1)) {
-                if (tasks.sDataCursor.getVoxel(x, y, z - 1)) {
-                    const d = Distance3D(sx, sy, sz, x, y, z - 1);
-                    if (d <= radius) {
-                        queue.push([x, y, z - 1]);
-                    }
-                }
-                map.add(x, y, z - 1);
-            }
-            if (!map.inMap(x, y + 1, z)) {
-                if (tasks.sDataCursor.getVoxel(x, y + 1, z)) {
-                    const d = Distance3D(sx, sy, sz, x, y + 1, z);
-                    if (d <= radius) {
-                        queue.push([x, y + 1, z]);
-                    }
-                }
-                map.add(x, y + 1, z);
-            }
-            if (!map.inMap(x, y - 1, z)) {
-                if (tasks.sDataCursor.getVoxel(x, y - 1, z)) {
-                    const d = Distance3D(sx, sy, sz, x, y - 1, z);
-                    if (d <= radius) {
-                        queue.push([x, y - 1, z]);
-                    }
-                }
-                map.add(x, y - 1, z);
-            }
-            const voxel = tasks.sDataCursor.getVoxel(x, y, z);
-            if (voxel) {
-                if (voxel.isRenderable()) {
-                    for (const n of $3dCardinalNeighbors) {
-                        const nx = x + n[0];
-                        const ny = y + n[1];
-                        const nz = z + n[2];
-                        const nvoxel = tasks.nDataCursor.getVoxel(x, y, z);
-                        if (nvoxel) {
-                            const l = nvoxel.getLight();
-                            if (l > 0) {
-                                if (lightData.getS(l) > 0) {
-                                    tasks.sun.remove.push(nx, ny, nz);
-                                }
-                                if (lightData.hasRGBLight(l)) {
-                                    tasks.rgb.remove.push(nx, ny, nz);
-                                }
-                            }
-                        }
-                    }
-                    tasks.bounds.update(x, y, z);
-                    /*           if (
-                                voxel.getHardness() > 10_000 ||
-                                voxel.getSubstnaceData().isLiquid()
-                              ) {
-                                continue;
-                              } */
-                    voxel.setAir().updateVoxel(1);
-                }
-            }
-        }
-        RGBRemove(tasks);
-        SunRemove(tasks);
-        RGBUpdate(tasks);
-        SunUpdate(tasks);
-        // tasks.runRebuildQueue();
-    },
-};

package/Tasks/Update/Common.d.ts

@@ -1,3 +0,0 @@
-import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
-export declare const updateLightTask: (tasks: VoxelUpdateTask) => void;
-export declare const updatePowerTask: (tasks: VoxelUpdateTask) => void;

package/Tasks/Update/Common.js

@@ -1,41 +0,0 @@
-import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
-export const updateLightTask = (tasks) => {
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    const [dimension, x, y, z] = tasks.origin;
-    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
-    for (const n of $3dCardinalNeighbors) {
-        const nx = n[0] + x;
-        const ny = n[1] + y;
-        const nz = n[2] + z;
-        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
-        if (!nVoxel)
-            continue;
-        if (doRGB) {
-            if (nVoxel.hasRGBLight()) {
-                tasks.rgb.update.push(nx, ny, nz);
-            }
-        }
-        if (doSun) {
-            if (nVoxel.hasSunLight()) {
-                tasks.sun.update.push(nx, ny, nz);
-            }
-        }
-    }
-};
-export const updatePowerTask = (tasks) => {
-    const [dimension, x, y, z] = tasks.origin;
-    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
-    for (const n of $3dCardinalNeighbors) {
-        const nx = n[0] + x;
-        const ny = n[1] + y;
-        const nz = n[2] + z;
-        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
-        if (!nVoxel)
-            continue;
-        if (nVoxel.getPower() > 0) {
-            tasks.power.update.push(nx, ny, nz);
-        }
-    }
-};

package/Tasks/Update/EreaseUpdate.d.ts

@@ -1,3 +0,0 @@
-import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
-import { LocationData } from "../../Math/index.js";
-export declare function EreaseAndUpdate(location: LocationData): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/EreaseUpdate.js

@@ -1,66 +0,0 @@
-import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
-import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
-import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
-import { SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
-import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
-import { updateLightTask } from "./Common.js";
-import { PowerRemove, PowerUpdate } from "../Propagation/Power/PowerUpdate.js";
-const tasks = new VoxelUpdateTask();
-export async function EreaseAndUpdate(location) {
-    const [dimension, x, y, z] = location;
-    tasks.setOrigin(location);
-    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    const substanceData = voxel.getSubstanceData();
-    const foundPower = voxel.getPower();
-    if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
-        if (substanceData["dve_is_liquid"]) {
-            FlowRemove(tasks);
-            return tasks;
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    const light = voxel.getLight();
-    const isLightSource = voxel.isLightSource();
-    voxel.setSecondary(true).setId(0).setSecondary(false);
-    voxel
-        .setLight(light > 0 ? light : 0)
-        .setId(0)
-        .setLevel(0)
-        .setLevelState(0)
-        .setState(0)
-        .setMod(0)
-        .updateVoxel(1);
-    if (ES.doLight) {
-        if (ES.doRGBPropagation && isLightSource) {
-            tasks.rgb.remove.push(x, y, z);
-            RGBRemove(tasks);
-        }
-        updateLightTask(tasks);
-        if (ES.doRGBPropagation) {
-            RGBUpdate(tasks);
-        }
-        if (ES.doSunPropagation) {
-            SunUpdate(tasks);
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (ES.doPower) {
-        if (foundPower > -1) {
-            voxel.setLevel(foundPower);
-            tasks.power.remove.push(x, y, z);
-            PowerRemove(tasks);
-            PowerUpdate(tasks);
-        }
-    }
-    tasks.bounds.update(x, y, z);
-    tasks.bounds.update(x + 1, y + 1, z + 1);
-    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-        tasks.sDataCursor
-            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
-            ?.updateVoxel(2);
-    }
-    return tasks;
-}

package/Tasks/Update/InitTasks.d.ts

@@ -1,5 +0,0 @@
-import { Thread } from "@amodx/threads";
-import { VoxelUpdateTask } from "../VoxelUpdateTask";
-export default function (props: {
-    onDone(taks: VoxelUpdateTask, origin: Thread): void;
-}): void;

package/Tasks/Update/InitTasks.js

@@ -1,25 +0,0 @@
-import { Threads } from "@amodx/threads";
-import { TasksIds } from "../TasksIds";
-import { VoxelUpdate } from "./VoxelUpdate";
-import { EreaseAndUpdate } from "./EreaseUpdate";
-import { PaintAndUpdate } from "./PaintUpdate";
-export default function (props) {
-    Threads.registerTask(TasksIds.VoxelUpdate, async (data, origin) => {
-        const tasks = await VoxelUpdate(data);
-        if (!tasks)
-            return;
-        props.onDone(tasks, origin);
-    });
-    Threads.registerTask(TasksIds.VoxelErease, async (data, origin) => {
-        const tasks = await EreaseAndUpdate(data);
-        if (!tasks)
-            return;
-        props.onDone(tasks, origin);
-    });
-    Threads.registerTask(TasksIds.VoxelPaint, async (data, origin) => {
-        const tasks = await PaintAndUpdate(data);
-        if (!tasks)
-            return;
-        props.onDone(tasks, origin);
-    });
-}

package/Tasks/Update/PaintUpdate.d.ts

@@ -1,3 +0,0 @@
-import { VoxelUpdateTasks } from "../Tasks.types.js";
-import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
-export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/PaintUpdate.js

@@ -1,89 +0,0 @@
-import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
-import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
-import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
-import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
-import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
-import { updateLightTask, updatePowerTask } from "./Common.js";
-import { PowerUpdate } from "../../Tasks/Propagation/Power/PowerUpdate.js";
-const tasks = new VoxelUpdateTask();
-export async function PaintAndUpdate(data) {
-    const [dimension, x, y, z] = data[0];
-    tasks.setOrigin(data[0]);
-    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    const raw = data[1];
-    const isOpaque = voxel.isOpaque();
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    lighttest: if (ES.doLight) {
-        const light = voxel.getLight();
-        if (light <= 0)
-            break lighttest;
-        if (doSun) {
-            if (voxel.hasSunLight()) {
-                tasks.sun.remove.push(x, y, z);
-                SunRemove(tasks);
-            }
-        }
-        if (doRGB) {
-            if (voxel.hasRGBLight() && isOpaque) {
-                tasks.rgb.remove.push(x, y, z);
-                RGBRemove(tasks);
-            }
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    const id = raw[0];
-    if (id < 0)
-        return false;
-    voxel.setId(id);
-    voxel.setLevel(raw[2]);
-    voxel.setState(raw[3]);
-    voxel.setMod(raw[4]);
-    voxel.process();
-    if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
-        voxel.setSecondary(true);
-        voxel.setId(raw[5]);
-        voxel.setSecondary(false);
-    }
-    if (voxel.isLightSource() && voxel.getLightSourceValue()) {
-        voxel.setLight(voxel.getLightSourceValue());
-    }
-    voxel.updateVoxel(0);
-    if (ES.doLight) {
-        updateLightTask(tasks);
-        if (doRGB) {
-            tasks.rgb.update.push(x, y, z);
-            RGBUpdate(tasks);
-        }
-        if (doSun) {
-            SunUpdate(tasks);
-        }
-    }
-    voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (ES.doFlow) {
-        if (!voxel.isAir() && voxel.getSubstanceData()["dve_is_liquid"]) {
-            FlowUpdate(tasks);
-        }
-    }
-    if (ES.doPower) {
-        if (voxel._tags["dve_can_be_powered"] ||
-            voxel._tags["dve_is_power_source"] ||
-            voxel._tags["dve_can_carry_power"] ||
-            voxel._tags["dve_can_hold_power"]) {
-            updatePowerTask(tasks);
-            tasks.power.update.push(x, y, z);
-            PowerUpdate(tasks);
-        }
-    }
-    tasks.bounds.update(x, y, z);
-    tasks.bounds.update(x + 1, y + 1, z + 1);
-    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-        tasks.sDataCursor
-            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
-            ?.updateVoxel(2);
-    }
-    return tasks;
-}

package/Tasks/Update/VoxelUpdate.d.ts

@@ -1,3 +0,0 @@
-import { VoxelUpdateTasks } from "../Tasks.types.js";
-import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
-export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | VoxelUpdateTask>;

package/Tasks/Update/VoxelUpdate.js

@@ -1,35 +0,0 @@
-import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
-import { RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
-import { SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
-import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
-import { updateLightTask } from "./Common.js";
-const tasks = new VoxelUpdateTask();
-export async function VoxelUpdate(data) {
-    const [dimension, x, y, z] = data[0];
-    tasks.setOrigin(data[0]);
-    const voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (!voxel)
-        return false;
-    let doRGB = ES.doRGBPropagation;
-    let doSun = ES.doSunPropagation;
-    if (ES.doLight) {
-        updateLightTask(tasks);
-        if (doRGB) {
-            tasks.rgb.update.push(x, y, z);
-            RGBUpdate(tasks);
-        }
-        if (doSun) {
-            tasks.sun.update.push(x, y, z);
-            SunUpdate(tasks);
-        }
-    }
-    if (ES.doFlow) {
-        if (voxel.getSubstanceData()["dve_is_solid"]) {
-            FlowUpdate(tasks);
-        }
-    }
-    tasks.bounds.update(x, y, z);
-    tasks.bounds.update(x + 1, y + 1, z + 1);
-    return tasks;
-}

package/Templates/FullVoxelTemplate.d.ts

@@ -1,14 +0,0 @@
-import { Flat3DIndex, Vec3Array } from "@amodx/math";
-import { FullVoxelTemplateData } from "./VoxelTemplates.types";
-export declare class FullVoxelTemplate {
-    static CreateNew(size: Vec3Array, baseLightValue?: number): FullVoxelTemplateData;
-    index: Flat3DIndex;
-    size: Vec3Array;
-    ids: Uint16Array;
-    level: Uint8Array;
-    state: Uint16Array;
-    light: Uint16Array;
-    mod: Uint16Array;
-    secondary: Uint16Array;
-    constructor(data: FullVoxelTemplateData);
-}

package/Templates/FullVoxelTemplate.js

@@ -1,61 +0,0 @@
-import { Flat3DIndex } from "@amodx/math";
-export class FullVoxelTemplate {
-    static CreateNew(size, baseLightValue = 0) {
-        const voxelSize = size[0] * size[1] * size[2];
-        const sectionBuffer = new SharedArrayBuffer(
-        //ids
-        voxelSize * 2 +
-            //light
-            voxelSize * 2 +
-            //state
-            voxelSize * 2 +
-            //mod
-            voxelSize * 2 +
-            //secondary
-            voxelSize * 2 +
-            //level
-            voxelSize);
-        let bufferStart = 0;
-        const ids = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const light = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        if (baseLightValue)
-            light.fill(baseLightValue);
-        const state = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const mod = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const secondary = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize * 2;
-        const level = new Uint8Array(sectionBuffer, bufferStart, voxelSize);
-        bufferStart += voxelSize;
-        return {
-            size,
-            ids,
-            light,
-            level,
-            state,
-            secondary,
-            mod,
-        };
-    }
-    index = Flat3DIndex.GetXZYOrder();
-    size;
-    ids;
-    level;
-    state;
-    light;
-    mod;
-    secondary;
-    constructor(data) {
-        this.size = [...data.size];
-        this.index.setBounds(...data.size);
-        this.ids = data.ids;
-        this.level = data.level;
-        this.state = data.state;
-        this.light = data.light;
-        this.mod = data.mod;
-        this.secondary = data.secondary;
-    }
-}

package/Templates/Functions/CreateTemplate.d.ts

@@ -1,3 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { VoxelTemplate } from "../VoxelTemplate";
-export default function CreateTemplate(dimension: number, start: Vec3Array, end: Vec3Array): VoxelTemplate;

package/Templates/Functions/CreateTemplate.js

@@ -1,134 +0,0 @@
-import { Flat3DIndex, Traverse } from "@amodx/math";
-import { StringPalette } from "../../Util/StringPalette";
-import { VoxelTemplate } from "../VoxelTemplate";
-import { NumberPalette } from "../../Util/NumberPalette";
-import { convertToPaletteBuffer } from "../../Util/Binary/Palettes";
-import { WorldCursor } from "../../World";
-export default function CreateTemplate(dimension, start, end) {
-    const dataTool = new WorldCursor();
-    dataTool.setFocalPoint(dimension, start[0], start[1], start[2]);
-    const index = Flat3DIndex.GetXZYOrder();
-    const [sx, sy, sz] = [
-        end[0] - start[0],
-        end[1] - start[1],
-        end[2] - start[2],
-    ];
-    index.setBounds(sx, sy, sz);
-    const idPalette = new StringPalette();
-    const levelPalette = new NumberPalette();
-    const statePalette = new NumberPalette();
-    const modPalette = new NumberPalette();
-    const secondaryIdPalette = new StringPalette();
-    const secondaryStatePalette = new NumberPalette();
-    const ids = new Uint16Array(index.size);
-    const levels = new Uint8Array(index.size);
-    const states = new Uint16Array(index.size);
-    const mods = new Uint16Array(index.size);
-    const secondarys = new Uint16Array(index.size);
-    let idsAllTheSame = true;
-    let levelAllTheSame = true;
-    let stateAllTheSame = true;
-    let modAllTheSame = true;
-    let secondaryAllTheSame = true;
-    let firstId = -1;
-    let firstLevel = -1;
-    let firstState = -1;
-    let firstMod = -1;
-    let firstSecondary = -1;
-    for (const { x, y, z } of Traverse.FromToVec3(start, [end[0] - 1, end[1] - 1, end[2] - 1], 1)) {
-        const voxel = dataTool.getVoxel(x, y, x);
-        if (!voxel)
-            continue;
-        const vindex = index.getIndexXYZ(x - start[0], y - start[1], z - start[2]);
-        const rawData = voxel.getRaw();
-        const level = rawData[2];
-        const state = rawData[3];
-        const mod = rawData[4];
-        const seoncdary = rawData[5];
-        const stringId = voxel.getStringId();
-        const voxelId = !idPalette.isRegistered(stringId)
-            ? idPalette.register(stringId)
-            : idPalette.getNumberId(stringId);
-        const levelId = !levelPalette.isRegistered(level)
-            ? levelPalette.register(level)
-            : levelPalette.getId(level);
-        const stateId = !statePalette.isRegistered(state)
-            ? statePalette.register(state)
-            : statePalette.getId(state);
-        const modId = !modPalette.isRegistered(mod)
-            ? modPalette.register(mod)
-            : modPalette.getId(mod);
-        let secondaryData = 0;
-        if (voxel.canHaveSecondaryVoxel()) {
-            voxel.setSecondary(true);
-            let secondaryId = voxel.hasSecondaryVoxel()
-                ? voxel.getStringId()
-                : "dve_air";
-            voxel.setSecondary(false);
-            secondaryData = !secondaryIdPalette.isRegistered(secondaryId)
-                ? secondaryIdPalette.register(secondaryId)
-                : secondaryIdPalette.getNumberId(secondaryId);
-        }
-        else {
-            secondaryData = !secondaryStatePalette.isRegistered(seoncdary)
-                ? secondaryStatePalette.register(seoncdary)
-                : secondaryStatePalette.getId(seoncdary);
-        }
-        if (firstId == -1)
-            firstId = voxelId;
-        if (firstLevel == -1)
-            firstLevel = stateId;
-        if (firstState == -1)
-            firstState = stateId;
-        if (firstMod == -1)
-            firstMod = modId;
-        if (firstSecondary == -1)
-            firstSecondary = secondaryData;
-        ids[vindex] = voxelId;
-        levels[vindex] = voxelId;
-        mods[vindex] = modId;
-        states[vindex] = stateId;
-        secondarys[vindex] = secondaryData;
-        if (firstId != voxelId)
-            idsAllTheSame = false;
-        if (firstLevel != levelId)
-            levelAllTheSame = false;
-        if (firstState != stateId)
-            stateAllTheSame = false;
-        if (firstMod != modId)
-            modAllTheSame = false;
-        if (firstSecondary != secondaryData)
-            secondaryAllTheSame = false;
-    }
-    console.log("CREATE VOXEL TEMPLATE", { modPalette, mod: mods });
-    return new VoxelTemplate({
-        templatorVersion: 0,
-        version: 0,
-        size: [sx, sy, sz],
-        palettes: {
-            id: idPalette._palette,
-            level: Uint8Array.from(levelPalette._palette),
-            state: Uint16Array.from(statePalette._palette),
-            mod: Uint16Array.from(modPalette._palette),
-            secondaryId: secondaryIdPalette._palette,
-            secondaryState: Uint16Array.from(secondaryStatePalette._palette),
-        },
-        buffers: {
-            ids: !idsAllTheSame
-                ? convertToPaletteBuffer(idPalette.size, Uint16Array.from(ids), true)
-                : ids[0],
-            level: !levelAllTheSame
-                ? convertToPaletteBuffer(modPalette.size, levels, true)
-                : levels[0],
-            mod: !modAllTheSame
-                ? convertToPaletteBuffer(modPalette.size, Uint16Array.from(mods), true)
-                : mods[0],
-            state: !stateAllTheSame
-                ? convertToPaletteBuffer(statePalette.size, Uint16Array.from(states), true)
-                : states[0],
-            secondary: !secondaryAllTheSame
-                ? convertToPaletteBuffer(Math.max(secondaryIdPalette.size, secondaryStatePalette.size), Uint16Array.from(secondarys), true)
-                : secondarys[0],
-        },
-    });
-}

package/Templates/VoxelTemplate.d.ts

@@ -1,34 +0,0 @@
-import { Flat3DIndex, Vec3Array } from "@amodx/math";
-import { VoxelTemplateData } from "./VoxelTemplates.types";
-import type { RawVoxelData } from "../Voxels/Types/Voxel.types";
-import { StringPalette } from "../Util/StringPalette";
-import { NumberPalette } from "../Util/NumberPalette";
-type TemplateCursor = {
-    position: Vec3Array;
-    raw: RawVoxelData;
-};
-export declare class VoxelTemplate {
-    index: Flat3DIndex;
-    size: Vec3Array;
-    ids: Uint8Array | Uint16Array | number;
-    level: Uint8Array | number;
-    state: Uint8Array | Uint16Array | number;
-    mod: Uint8Array | Uint16Array | number;
-    secondary: Uint8Array | Uint16Array | number;
-    idPalette: StringPalette;
-    levelPalette: NumberPalette;
-    statePalette: NumberPalette;
-    modPalette: NumberPalette;
-    secondaryIdPalette: StringPalette;
-    secondaryStatePalette: NumberPalette;
-    constructor(data: VoxelTemplateData);
-    getIndex(x: number, y: number, z: number): number;
-    getId(index: number): number;
-    getState(index: number): number;
-    getLevel(index: number): number;
-    getMod(index: number): number;
-    getSecondary(id: number, index: number): number;
-    traverse(): Generator<TemplateCursor>;
-    toJSON(): VoxelTemplateData;
-}
-export {};