@divinevoxel/vlox 0.0.4 → 0.0.6

package/Tasks/WorldGeneration/WorldGenRegister.js

@@ -1,11 +1,9 @@
-import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
+import { WorldSpaces } from "../../World/WorldSpaces.js";
 import { BrushTool } from "../../Tools/Brush/Brush";
-import { ChunkDataTool } from "../../Tools/Data/WorldData/ChunkDataTool";
-import { WorldBounds } from "../../Data/World/WorldBounds";
 import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor";
+import { WorldRegister } from "../../World/WorldRegister";
 const brush = new BrushTool();
 const dataTool = brush.voxelCursor;
-const chunkTool = new ChunkDataTool();
 export class WorldGenRegister {
     static MAX_ATTEMPTS = 100;
     static _requests = new Map();
@@ -13,30 +11,30 @@ export class WorldGenRegister {
         const id = location.toString();
         this._requests.set(id, {
             attempts: 0,
-            chunks: new Map(),
+            sections: new Map(),
             dimension: location[0],
             voxels: [],
         });
         return id;
     }
     static addToRequest(registerId, location, rawData) {
-        if (location[2] < WorldBounds.bounds.MinY ||
-            location[2] >= WorldBounds.bounds.MaxY)
+        if (location[2] < WorldSpaces.world.bounds.MinY ||
+            location[2] >= WorldSpaces.world.bounds.MaxY)
             return false;
         const requests = this._requests.get(registerId);
         if (!requests)
             return;
-        const chunkPOS = WorldSpaces.chunk.getPositionXYZ(location[1], location[2], location[3]);
-        const chunkKey = WorldSpaces.chunk.getKeyXYZ(location[1], location[2], location[3]);
-        if (!chunkTool.loadInAtLocation(location)) {
-            if (!requests.chunks.has(chunkKey)) {
-                DivineVoxelEngineConstructor.instance.threads.world.runTasks("add-chunk", [
-                    requests.dimension,
-                    chunkPOS.x,
-                    chunkPOS.y,
-                    chunkPOS.z,
+        const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+        if (!sector) {
+            const sectorPos = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
+            const sectorKey = WorldSpaces.hash.hashVec3(sectorPos);
+            if (!requests.sections.has(sectorKey)) {
+                DivineVoxelEngineConstructor.instance.threads.world.runTask("add-sector", [requests.dimension, sectorPos.x, sectorPos.y, sectorPos.z]);
+                requests.sections.set(sectorKey, [
+                    sectorPos.x,
+                    sectorPos.y,
+                    sectorPos.z,
                 ]);
-                requests.chunks.set(chunkKey, [chunkPOS.x, chunkPOS.y, chunkPOS.z]);
             }
         }
         const [dim, x, y, z] = location;
@@ -46,25 +44,14 @@ export class WorldGenRegister {
         const requests = this._requests.get(registerId);
         if (!requests || !requests.voxels.length)
             return true;
-        chunkTool.setDimension(requests.dimension);
         let done = true;
-        for (const [key, pos] of requests.chunks) {
-            if (pos[0] < WorldBounds.bounds.MinX ||
-                pos[0] > WorldBounds.bounds.MaxX ||
-                pos[1] < WorldBounds.bounds.MinY ||
-                pos[1] > WorldBounds.bounds.MaxY ||
-                pos[2] < WorldBounds.bounds.MinZ ||
-                pos[2] > WorldBounds.bounds.MaxZ) {
+        for (const [key, pos] of requests.sections) {
+            if (!WorldSpaces.world.inBounds(pos[0], pos[1], pos[2]))
                 continue;
-            }
-            if (!chunkTool.loadInAt(pos[0], pos[1], pos[2])) {
+            const sector = WorldRegister.sectors.get(requests.dimension, pos[0], pos[1], pos[2]);
+            if (!sector) {
                 done = false;
-                DivineVoxelEngineConstructor.instance.threads.world.runTasks("add-chunk", [
-                    requests.dimension,
-                    pos[0],
-                    pos[1],
-                    pos[2],
-                ]);
+                DivineVoxelEngineConstructor.instance.threads.world.runTask("add-sector", [requests.dimension, pos[0], pos[1], pos[2]]);
             }
         }
         if (!done) {
@@ -77,15 +64,15 @@ export class WorldGenRegister {
             return false;
         }
         /*     brush.setDimension(requests.dimension);
-            dataTool.setDimension(requests.dimension);
-            const voxels = requests.voxels;
-            brush.start();
-            while (voxels.length) {
-              const data = voxels.shift();
-              if (!data) break;
-              dataTool.loadInAt(data[0], data[1], data[2]);
-              brush.setXYZ(data[0], data[1], data[2]).setRaw(data[3]).paint();
-            } */
+        dataTool.setDimension(requests.dimension);
+        const voxels = requests.voxels;
+        brush.start();
+        while (voxels.length) {
+          const data = voxels.shift();
+          if (!data) break;
+          dataTool.loadInAt(data[0], data[1], data[2]);
+          brush.setXYZ(data[0], data[1], data[2]).setRaw(data[3]).paint();
+        } */
         brush.stop();
         this._requests.delete(registerId);
         return true;

package/Tasks/WorldGeneration/WorldGeneration.d.ts

@@ -1,4 +1,3 @@
-import { WorldBounds } from "../../Data/World/WorldBounds.js";
 import { WorldGenRegister } from "./WorldGenRegister.js";
 import { WorldGenBrush } from "./WorldGenBrush.js";
 import { WorldGenInterface } from "./WorldGen.types.js";
@@ -6,7 +5,6 @@ import { GenerateTasks } from "../Tasks.types.js";
 export declare class WorldGeneration {
     static worldGen: WorldGenInterface | null;
     static register: typeof WorldGenRegister;
-    static worldBounds: typeof WorldBounds;
     static _brushes: any[];
     static setWorldGen(worldGen: WorldGenInterface): void;
     static generate(data: GenerateTasks, mode: "generate" | "decorate", onDone: Function): Promise<void>;

package/Tasks/WorldGeneration/WorldGeneration.js

@@ -1,14 +1,11 @@
 //types
 //objects
-import { WorldBounds } from "../../Data/World/WorldBounds.js";
 import { WorldGenRegister } from "./WorldGenRegister.js";
 //tools
 import { WorldGenBrush } from "./WorldGenBrush.js";
-import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
 export class WorldGeneration {
     static worldGen = null;
     static register = WorldGenRegister;
-    static worldBounds = WorldBounds;
     static _brushes = [];
     static setWorldGen(worldGen) {
         this.worldGen = worldGen;
@@ -27,16 +24,21 @@ export class WorldGeneration {
         if (mode == "decorate") {
             await this.worldGen.decorate(data);
         }
-        const inte = new SafeInterval().setInterval(100).setOnRun(() => {
-            if (WorldGenRegister.attemptRequestFullFill(requestsId)) {
-                onDone();
-                inte.stop();
-            }
-        });
-        inte.start();
+        if (!WorldGenRegister.attemptRequestFullFill(requestsId)) {
+            const readyCheck = () => {
+                if (WorldGenRegister.attemptRequestFullFill(requestsId)) {
+                    onDone();
+                    return;
+                }
+                setTimeout(readyCheck, 10);
+            };
+            readyCheck();
+        }
+        else {
+            onDone();
+        }
     }
     static getBrush() {
-        const brush = new WorldGenBrush();
-        return brush;
+        return new WorldGenBrush();
     }
 }

package/{Data/Cursor/Template → Templates/Cursor}/TemplateCursor.d.ts

@@ -1,5 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
 import { FullVoxelTemplate } from "Templates/FullVoxelTemplate";
 export declare class TemplateCursor extends DataCursorInterface {
     _voxelIndex: number;

package/{Data/Cursor/Template → Templates/Cursor}/TemplateCursor.js

@@ -1,5 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
 export class TemplateCursor extends DataCursorInterface {
     _voxelIndex = 0;
     _template = null;

package/{Data/Cursor/Template → Templates/Cursor}/TemplateVoxelCursor.d.ts

@@ -1,9 +1,10 @@
-import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 import { TemplateCursor } from "./TemplateCursor";
 export declare class TemplateVoxelCursor extends VoxelCursorInterface {
     dataCursor: TemplateCursor;
     private _template;
     get ids(): Uint16Array;
+    get level(): Uint8Array;
     get light(): Uint16Array;
     get state(): Uint16Array;
     get secondary(): Uint16Array;

package/{Data/Cursor/Template → Templates/Cursor}/TemplateVoxelCursor.js

@@ -1,10 +1,13 @@
-import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export class TemplateVoxelCursor extends VoxelCursorInterface {
     dataCursor;
     _template;
     get ids() {
         return this._template.ids;
     }
+    get level() {
+        return this._template.level;
+    }
     get light() {
         return this._template.light;
     }

package/Templates/FullVoxelTemplate.d.ts

@@ -5,6 +5,7 @@ export declare class FullVoxelTemplate {
     index: Flat3DIndex;
     size: Vec3Array;
     ids: Uint16Array;
+    level: Uint8Array;
     state: Uint16Array;
     light: Uint16Array;
     mod: Uint16Array;

package/Templates/FullVoxelTemplate.js

@@ -2,7 +2,7 @@ import { Flat3DIndex } from "@amodx/math";
 export class FullVoxelTemplate {
     static CreateNew(size, baseLightValue = 0) {
         const voxelSize = size[0] * size[1] * size[2];
-        const chunkBuffer = new SharedArrayBuffer(
+        const sectionBuffer = new SharedArrayBuffer(
         //ids
         voxelSize * 2 +
             //light
@@ -12,24 +12,29 @@ export class FullVoxelTemplate {
             //mod
             voxelSize * 2 +
             //secondary
-            voxelSize * 2);
+            voxelSize * 2 +
+            //level
+            voxelSize);
         let bufferStart = 0;
-        const ids = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const ids = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
-        const light = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const light = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
         if (baseLightValue)
             light.fill(baseLightValue);
-        const state = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const state = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
-        const mod = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const mod = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
-        const secondary = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        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,
@@ -38,6 +43,7 @@ export class FullVoxelTemplate {
     index = Flat3DIndex.GetXZYOrder();
     size;
     ids;
+    level;
     state;
     light;
     mod;
@@ -46,6 +52,7 @@ export class FullVoxelTemplate {
         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;

package/Templates/Functions/CreateTemplate.js

@@ -2,10 +2,11 @@ import { Flat3DIndex, Traverse } from "@amodx/math";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelTemplate } from "../VoxelTemplate";
 import { NumberPalette } from "../../Util/NumberPalette";
-import { DataTool } from "../../Tools/Data/DataTool";
-import { convertToPaletteBuffer } from "../../Archive/Functions/Palettes";
+import { convertToPaletteBuffer } from "../../Data/Functions/Palettes";
+import { WorldCursor } from "../../World";
 export default function CreateTemplate(dimension, start, end) {
-    const dataTool = new DataTool();
+    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],
@@ -14,56 +15,69 @@ export default function CreateTemplate(dimension, start, end) {
     ];
     index.setBounds(sx, sy, sz);
     const idPalette = new StringPalette();
-    const secondaryIdPalette = 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 Array(index.size);
-    const state = new Array(index.size);
-    const mod = new Array(index.size);
-    const secondary = new Array(index.size);
-    dataTool.setDimension(dimension);
+    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)) {
-        if (!dataTool.loadInAt(x, y, z))
+        const voxel = dataTool.getVoxel(x, y, x);
+        if (!voxel)
             continue;
         const vindex = index.getIndexXYZ(x - start[0], y - start[1], z - start[2]);
-        const raw = dataTool.getRaw();
-        const stringId = dataTool.getStringId();
-        const stateId = !statePalette.isRegistered(raw[2])
-            ? statePalette.register(raw[2])
-            : statePalette.getId(raw[2]);
-        const modId = !modPalette.isRegistered(raw[4])
-            ? modPalette.register(raw[4])
-            : modPalette.getId(raw[4]);
+        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 (dataTool.canHaveSecondaryVoxel()) {
-            dataTool.setSecondary(true);
-            let secondaryId = dataTool.hasSecondaryVoxel()
-                ? dataTool.getStringId()
+        if (voxel.canHaveSecondaryVoxel()) {
+            voxel.setSecondary(true);
+            let secondaryId = voxel.hasSecondaryVoxel()
+                ? voxel.getStringId()
                 : "dve_air";
-            dataTool.setSecondary(false);
+            voxel.setSecondary(false);
             secondaryData = !secondaryIdPalette.isRegistered(secondaryId)
                 ? secondaryIdPalette.register(secondaryId)
                 : secondaryIdPalette.getNumberId(secondaryId);
         }
         else {
-            secondaryData = !secondaryStatePalette.isRegistered(raw[3])
-                ? secondaryStatePalette.register(raw[3])
-                : secondaryStatePalette.getId(raw[3]);
+            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)
@@ -71,11 +85,14 @@ export default function CreateTemplate(dimension, start, end) {
         if (firstSecondary == -1)
             firstSecondary = secondaryData;
         ids[vindex] = voxelId;
-        mod[vindex] = modId;
-        state[vindex] = stateId;
-        secondary[vindex] = secondaryData;
+        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)
@@ -83,31 +100,35 @@ export default function CreateTemplate(dimension, start, end) {
         if (firstSecondary != secondaryData)
             secondaryAllTheSame = false;
     }
-    console.log("CREATE VOXEL TEMPLATE", { modPalette, mod });
+    console.log("CREATE VOXEL TEMPLATE", { modPalette, mod: mods });
     return new VoxelTemplate({
         templatorVersion: 0,
         version: 0,
         size: [sx, sy, sz],
         palettes: {
             id: idPalette._palette,
-            secondaryId: secondaryIdPalette._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(mod), true)
-                : mod[0],
+                ? convertToPaletteBuffer(modPalette.size, Uint16Array.from(mods), true)
+                : mods[0],
             state: !stateAllTheSame
-                ? convertToPaletteBuffer(statePalette.size, Uint16Array.from(state), true)
-                : state[0],
+                ? convertToPaletteBuffer(statePalette.size, Uint16Array.from(states), true)
+                : states[0],
             secondary: !secondaryAllTheSame
-                ? convertToPaletteBuffer(Math.max(secondaryIdPalette.size, secondaryStatePalette.size), Uint16Array.from(secondary), true)
-                : secondary[0],
+                ? convertToPaletteBuffer(Math.max(secondaryIdPalette.size, secondaryStatePalette.size), Uint16Array.from(secondarys), true)
+                : secondarys[0],
         },
     });
 }

package/Templates/Functions/FlipTemplate.js

@@ -32,6 +32,10 @@ export default function FlipTemplate(template, direction) {
         const ids = template.ids;
         flipArray([sizeX, sizeY, sizeZ], ids, direction, index);
     }
+    if (typeof template.level === "object") {
+        const level = template.level;
+        flipArray([sizeX, sizeY, sizeZ], level, direction, index);
+    }
     if (typeof template.state === "object") {
         const state = template.state;
         flipArray([sizeX, sizeY, sizeZ], state, direction, index);

package/Templates/Functions/RotateTemplate.js

@@ -93,6 +93,10 @@ export default function RotateTemplate(template, angle, axes = "y") {
         const ids = template.ids;
         rotateArray([sizeX, sizeY, sizeZ], ids, angle, axes, index, newIndex);
     }
+    if (typeof template.level === "object") {
+        const level = template.level;
+        rotateArray([sizeX, sizeY, sizeZ], level, angle, axes, index, newIndex);
+    }
     if (typeof template.state === "object") {
         const state = template.state;
         rotateArray([sizeX, sizeY, sizeZ], state, angle, axes, index, newIndex);

package/Templates/VoxelTemplate.d.ts

@@ -1,6 +1,6 @@
 import { Flat3DIndex, Vec3Array } from "@amodx/math";
 import { VoxelTemplateData } from "./VoxelTemplates.types";
-import type { RawVoxelData } from "../Voxels/Voxel.types";
+import type { RawVoxelData } from "../Voxels/Types/Voxel.types";
 import { StringPalette } from "../Util/StringPalette";
 import { NumberPalette } from "../Util/NumberPalette";
 type TemplateCursor = {
@@ -11,18 +11,21 @@ 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;
-    secondaryIdPalette: 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>;

package/Templates/VoxelTemplate.js

@@ -1,33 +1,39 @@
 import { Flat3DIndex, Traverse } from "@amodx/math";
 import { StringPalette } from "../Util/StringPalette";
 import { NumberPalette } from "../Util/NumberPalette";
-import { VoxelPalette } from "../Data/Palettes/VoxelPalette";
-import { VoxelStruct } from "../Data/Structs/VoxelStruct";
-import { VoxelStructIds } from "../Voxels/Voxel.types";
-import { getPaletteArray } from "../Archive/Functions/Palettes";
+import { VoxelPalette } from "../Voxels/Palettes/VoxelPalette";
+import { VoxelStruct } from "../Voxels/Structs/VoxelStruct";
+import { VoxelStructIds } from "../Voxels/Types/Voxel.types";
+import { getPaletteArray } from "../Data/Functions/Palettes";
 export class VoxelTemplate {
     index = Flat3DIndex.GetXZYOrder();
     size;
     ids;
+    level;
     state;
     mod;
     secondary;
-    idPalette = new StringPalette();
-    secondaryIdPalette = new StringPalette();
-    statePalette = new NumberPalette();
-    modPalette = new NumberPalette();
-    secondaryStatePalette = new NumberPalette();
+    idPalette;
+    levelPalette;
+    statePalette;
+    modPalette;
+    secondaryIdPalette;
+    secondaryStatePalette;
     constructor(data) {
         this.size = [...data.size];
         this.index.setBounds(...data.size);
-        data.palettes.id.forEach((_) => this.idPalette.register(_));
-        data.palettes.state.forEach((_) => this.statePalette.register(_));
-        data.palettes.mod.forEach((_) => this.modPalette.register(_));
-        data.palettes.secondaryId.forEach((_) => this.secondaryIdPalette.register(_));
-        data.palettes.secondaryState.forEach((_) => this.secondaryStatePalette.register(_));
+        this.idPalette = new StringPalette(data.palettes.id);
+        this.levelPalette = new NumberPalette(data.palettes.level);
+        this.statePalette = new NumberPalette(data.palettes.state);
+        this.modPalette = new NumberPalette(data.palettes.mod);
+        this.secondaryIdPalette = new StringPalette(data.palettes.secondaryId);
+        this.secondaryStatePalette = new NumberPalette(data.palettes.secondaryState);
         typeof data.buffers.ids == "object"
             ? (this.ids = getPaletteArray(data.palettes.id.length, data.buffers.ids))
             : (this.ids = data.buffers.ids);
+        typeof data.buffers.level == "object"
+            ? (this.level = getPaletteArray(data.palettes.level.length, data.buffers.level))
+            : (this.level = data.buffers.level);
         typeof data.buffers.state == "object"
             ? (this.state = getPaletteArray(data.palettes.state.length, data.buffers.state))
             : (this.state = data.buffers.state);
@@ -49,6 +55,10 @@ export class VoxelTemplate {
         const state = this.state;
         return this.statePalette.getValue(typeof state == "number" ? state : state[index]);
     }
+    getLevel(index) {
+        const mod = this.mod;
+        return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
+    }
     getMod(index) {
         const mod = this.mod;
         return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
@@ -63,7 +73,7 @@ export class VoxelTemplate {
     }
     *traverse() {
         const end = this.size;
-        const raw = [0, 0, 0, 0, 0];
+        const raw = [0, 0, 0, 0, 0, 0];
         const curosr = {
             position: [0, 0, 0],
             raw,
@@ -75,9 +85,10 @@ export class VoxelTemplate {
             curosr.position[2] = z;
             raw[0] = this.getId(vindex);
             raw[1] = 0;
-            raw[2] = this.getState(vindex);
-            raw[3] = this.getSecondary(raw[0], vindex);
+            raw[2] = this.getLevel(vindex);
+            raw[3] = this.getState(vindex);
             raw[4] = this.getMod(vindex);
+            raw[5] = this.getSecondary(raw[0], vindex);
             if (raw[0] < 1 && raw[3] < 1)
                 continue;
             yield curosr;
@@ -90,9 +101,10 @@ export class VoxelTemplate {
             size: this.size,
             palettes: {
                 id: this.idPalette._palette,
-                secondaryId: this.secondaryIdPalette._palette,
+                level: Uint8Array.from(this.statePalette._palette),
                 state: Uint16Array.from(this.statePalette._palette),
                 mod: Uint16Array.from(this.modPalette._palette),
+                secondaryId: this.secondaryIdPalette._palette,
                 secondaryState: Uint16Array.from(this.secondaryStatePalette._palette),
             },
             buffers: {
@@ -101,6 +113,9 @@ export class VoxelTemplate {
                     typeof this.ids == "number"
                     ? this.ids
                     : new Uint8Array(this.ids.buffer),
+                level: this.level instanceof Uint8Array || typeof this.level == "number"
+                    ? this.level
+                    : new Uint8Array(this.level.buffer),
                 mod: this.mod instanceof Uint16Array ||
                     this.mod instanceof Uint8Array ||
                     typeof this.mod == "number"

package/Templates/VoxelTemplates.types.d.ts

@@ -1,23 +1,21 @@
 import { Vec3Array } from "@amodx/math";
+import { VoxelDataArrays } from "../World";
 export interface VoxelTemplateBuffers {
     ids: Uint16Array | Uint8Array | number;
     state: Uint16Array | Uint8Array | number;
+    level: Uint8Array | number;
     mod: Uint16Array | Uint8Array | number;
     secondary: Uint16Array | Uint8Array | number;
 }
-export interface FullVoxelTemplateData {
+export interface FullVoxelTemplateData extends VoxelDataArrays {
     size: Vec3Array;
-    ids: Uint16Array;
-    state: Uint16Array;
-    light: Uint16Array;
-    mod: Uint16Array;
-    secondary: Uint16Array;
 }
 export interface VoxelTemplatePaletteData {
     id: string[];
-    secondaryId: string[];
+    level: Uint8Array;
     state: Uint16Array;
     mod: Uint16Array;
+    secondaryId: string[];
     secondaryState: Uint16Array;
 }
 export interface VoxelTemplateData {