@divinevoxel/vlox 0.0.73 → 0.0.75

package/Tasks/{Update/UpdateTask.js → VoxelUpdateTask.js}

@@ -1,7 +1,7 @@
-import { WorldCursor } from "../../World/Cursor/WorldCursor";
+import { WorldCursor } from "../World/Cursor/WorldCursor";
 import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../../World/WorldSpaces";
-import { WorldRegister } from "../../World/WorldRegister";
+import { WorldSpaces } from "../World/WorldSpaces";
+import { WorldRegister } from "../World/WorldRegister";
 export class TaskMap {
     _map = [];
     get size() {
@@ -33,37 +33,37 @@ const InfinityVec3 = Vector3Like.Create(Infinity, Infinity, Infinity);
 const tempPosition = Vector3Like.Create();
 class UpdatedBounds {
     _task;
-    min = Vector3Like.Clone(InfinityVec3);
-    max = Vector3Like.Clone(NegativeInfinityVec3);
-    dimension = "main";
+    displayMin = Vector3Like.Clone(InfinityVec3);
+    displayMax = Vector3Like.Clone(NegativeInfinityVec3);
+    dimension = 0;
     constructor(_task) {
         this._task = _task;
     }
     start(dimension) {
-        this.dimension = dimension || "main";
-        Vector3Like.Copy(this.min, InfinityVec3);
-        Vector3Like.Copy(this.max, NegativeInfinityVec3);
-    }
-    update(x, y, z) {
-        if (x < this.min.x)
-            this.min.x = x;
-        if (y < this.min.y)
-            this.min.y = y;
-        if (z < this.min.z)
-            this.min.z = z;
-        if (x > this.max.x)
-            this.max.x = x;
-        if (y > this.max.y)
-            this.max.y = y;
-        if (z > this.max.z)
-            this.max.z = z;
+        this.dimension = dimension || 0;
+        Vector3Like.Copy(this.displayMin, InfinityVec3);
+        Vector3Like.Copy(this.displayMax, NegativeInfinityVec3);
+    }
+    updateDisplay(x, y, z) {
+        if (x < this.displayMin.x)
+            this.displayMin.x = x;
+        if (y < this.displayMin.y)
+            this.displayMin.y = y;
+        if (z < this.displayMin.z)
+            this.displayMin.z = z;
+        if (x > this.displayMax.x)
+            this.displayMax.x = x;
+        if (y > this.displayMax.y)
+            this.displayMax.y = y;
+        if (z > this.displayMax.z)
+            this.displayMax.z = z;
     }
     getSections() {
-        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.z - 1, tempPosition);
+        const minSectionPos = WorldSpaces.section.getPosition(this.displayMin.x, this.displayMin.y, this.displayMin.z, tempPosition);
         const minX = minSectionPos.x;
         const minY = minSectionPos.y;
         const minZ = minSectionPos.z;
-        const maxSectionPos = WorldSpaces.section.getPosition(this.max.x + 1, this.max.y + 1, this.max.z + 1, tempPosition);
+        const maxSectionPos = WorldSpaces.section.getPosition(this.displayMax.x, this.displayMax.y, this.displayMax.z, tempPosition);
         const maxX = maxSectionPos.x;
         const maxY = maxSectionPos.y;
         const maxZ = maxSectionPos.z;
@@ -79,12 +79,20 @@ class UpdatedBounds {
         }
         return sectionPositions;
     }
-    markSectionsAsDirty() {
-        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.z - 1, tempPosition);
+    markDisplayDirty() {
+        if (this.displayMax.x == -Infinity ||
+            this.displayMax.y == -Infinity ||
+            this.displayMax.z == -Infinity)
+            return false;
+        if (this.displayMin.x == Infinity ||
+            this.displayMin.y == Infinity ||
+            this.displayMin.z == Infinity)
+            return false;
+        const minSectionPos = WorldSpaces.section.getPosition(this.displayMin.x - 1, this.displayMin.y - 1, this.displayMin.z - 1, tempPosition);
         const minX = minSectionPos.x;
         const minY = minSectionPos.y;
         const minZ = minSectionPos.z;
-        const maxSectionPos = WorldSpaces.section.getPosition(this.max.x + 1, this.max.y + 1, this.max.z + 1, tempPosition);
+        const maxSectionPos = WorldSpaces.section.getPosition(this.displayMax.x + 1, this.displayMax.y + 1, this.displayMax.z + 1, tempPosition);
         const maxX = maxSectionPos.x;
         const maxY = maxSectionPos.y;
         const maxZ = maxSectionPos.z;
@@ -97,34 +105,43 @@ class UpdatedBounds {
                     if (!sector)
                         continue;
                     const section = sector.getSection(x, y, z);
-                    section.setDirty(true);
+                    if (!section.canRender())
+                        continue;
+                    section.incrementTick(section._Ticks.displayDirty);
                 }
             }
         }
     }
 }
-export class UpdateTask {
+export class VoxelUpdateTask {
     flow = new FlowQueues();
     rgb = new LightQueue();
     sun = new LightQueue();
+    power = new PowerQueue();
     bounds = new UpdatedBounds(this);
     sDataCursor = new WorldCursor();
     nDataCursor = new WorldCursor();
-    origin;
-    setOrigin(origin) {
-        this.sDataCursor.setFocalPoint(...origin);
-        this.nDataCursor.setFocalPoint(...origin);
-        this.origin = origin;
-        this.rgb.removeMap.start(origin[1], origin[2], origin[3]);
-        this.sun.removeMap.start(origin[1], origin[2], origin[3]);
-        this.rgb.updateMap.start(origin[1], origin[2], origin[3]);
-        this.sun.updateMap.start(origin[1], origin[2], origin[3]);
-        this.flow.update.map.start(origin[1], origin[2], origin[3]);
-        this.flow.remove.map.start(origin[1], origin[2], origin[3]);
-        this.flow.remove.noRemoveMap.start(origin[1], origin[2], origin[3]);
-        this.bounds.start(origin[0]);
+    origin = [0, 0, 0, 0];
+    setOrigin(dimension, x, y, z) {
+        this.sDataCursor.setFocalPoint(dimension, x, y, z);
+        this.nDataCursor.setFocalPoint(dimension, x, y, z);
+        this.origin[0] = dimension;
+        this.origin[1] = x;
+        this.origin[2] = y;
+        this.origin[3] = z;
+        this.rgb.removeMap.start(x, y, z);
+        this.sun.removeMap.start(x, y, z);
+        this.rgb.updateMap.start(x, y, z);
+        this.sun.updateMap.start(x, y, z);
+        this.flow.update.map.start(x, y, z);
+        this.flow.remove.map.start(x, y, z);
+        this.flow.remove.noRemoveMap.start(x, y, z);
+        this.bounds.start(dimension);
         this.clear();
     }
+    setOriginAt(origin) {
+        this.setOrigin(...origin);
+    }
     clear() {
         this.rgb.clear();
         this.sun.clear();
@@ -161,3 +178,15 @@ class LightQueue {
         this.updateMap.clear();
     }
 }
+class PowerQueue {
+    update = [];
+    remove = [];
+    removeMap = new TaskMap();
+    updateMap = new TaskMap();
+    clear() {
+        this.update.length = 0;
+        this.remove.length = 0;
+        this.removeMap.clear();
+        this.updateMap.clear();
+    }
+}

package/Tasks/WorldGeneration/InitTasks.d.ts

@@ -1 +1,4 @@
-export default function (): void;
+import { Thread } from "@amodx/threads";
+export default function (props: {
+    worldThread: Thread;
+}): void;

package/Tasks/WorldGeneration/InitTasks.js

@@ -1,7 +1,10 @@
 import { Threads } from "@amodx/threads";
 import { WorldGeneration } from "./WorldGeneration";
 import { TasksIds } from "../../Tasks/TasksIds";
-export default function () {
-    Threads.registerTask(TasksIds.Generate, (data) => new Promise((resolve) => WorldGeneration.generate(data, "generate", resolve)));
-    Threads.registerTask(TasksIds.Decorate, (data) => new Promise((resolve) => WorldGeneration.generate(data, "decorate", resolve)));
+import { getLocationData } from "../../Util/LocationData";
+import { WorldGenRegister } from "./WorldGenRegister";
+export default function (props) {
+    WorldGenRegister._worldThread = props.worldThread;
+    Threads.registerBinaryTask(TasksIds.Generate, (data) => new Promise((resolve) => WorldGeneration.generate(getLocationData(data), "generate", resolve)));
+    Threads.registerBinaryTask(TasksIds.Decorate, (data) => new Promise((resolve) => WorldGeneration.generate(getLocationData(data), "decorate", resolve)));
 }

package/Tasks/WorldGeneration/WorldGen.types.d.ts

@@ -1,5 +1,4 @@
-import { GenerateTasks } from "../Tasks.types";
 export type WorldGenInterface = {
-    generate(data: GenerateTasks): Promise<any | void>;
-    decorate(data: GenerateTasks): Promise<any | void>;
+    generate(dimensionId: number, x: number, y: number, z: number): Promise<any | void>;
+    decorate(dimensionId: number, x: number, y: number, z: number): Promise<any | void>;
 };

package/Tasks/WorldGeneration/WorldGenBrush.d.ts

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

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -2,8 +2,7 @@ import { WorldGenRegister } from "./WorldGenRegister.js";
 import { BrushTool } from "../../Tools/Brush/Brush.js";
 import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
 import { WorldGeneration } from "./WorldGeneration.js";
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import { UpdateTask } from "../Update/UpdateTask.js";
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
 import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
 const lightData = new VoxelLightData();
@@ -13,10 +12,10 @@ export class WorldGenBrush extends BrushTool {
         WorldGeneration._brushes.push(this);
     }
     requestsId;
-    tasks = new UpdateTask();
+    tasks = new VoxelUpdateTask();
     start(dimension, x, y, z) {
         this.dataCursor.setFocalPoint(dimension, x, y, z);
-        this.tasks.setOrigin([dimension, x, y, z]);
+        this.tasks.setOriginAt([dimension, x, y, z]);
         this.dimension = dimension;
         this.x = x;
         this.y = y;
@@ -51,7 +50,7 @@ export class WorldGenBrush extends BrushTool {
             }
         }
         this._paint();
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
         return this;
     }
     getUpdatedSections() {
@@ -73,7 +72,7 @@ export class WorldGenBrush extends BrushTool {
             this.tasks.sun.update.push(this.x, this.y, this.z);
             //  Propagation.instance.sunUpdate(this.tasks);
         }
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
     }
     erase() {
         let voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
@@ -91,7 +90,7 @@ export class WorldGenBrush extends BrushTool {
             this.tasks.sun.remove.push(this.x, this.y, this.z);
             SunRemove(this.tasks);
         }
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
         return this;
     }
     runUpdates() {
@@ -101,9 +100,9 @@ export class WorldGenBrush extends BrushTool {
         this.tasks.sun.removeMap.clear();
     }
     worldAlloc(start, end) {
-        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-alloc", [this.dimension, start, end]);
+        return WorldGenRegister._worldThread.runTaskAsync("world-alloc", [this.dimension, start, end]);
     }
     worldDealloc(start, end) {
-        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-dealloc", [this.dimension, start, end]);
+        return WorldGenRegister._worldThread.runTaskAsync("world-dealloc", [this.dimension, start, end]);
     }
 }

package/Tasks/WorldGeneration/WorldGenRegister.d.ts

@@ -1,14 +1,16 @@
 import type { LocationData } from "../../Math";
 import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { Thread } from "@amodx/threads";
 export declare class WorldGenRegister {
+    static _worldThread: Thread;
     static MAX_ATTEMPTS: number;
     static _requests: Map<string, {
         attempts: number;
-        dimension: string;
+        dimension: number;
         sections: Map<string, [x: number, y: number, z: number]>;
         voxels: [x: number, y: number, z: number, data: RawVoxelData][];
     }>;
-    static registerRequest(location: LocationData): string;
+    static registerRequest(location: Readonly<LocationData>): string;
     static addToRequest(registerId: string, location: LocationData, rawData: RawVoxelData): false | undefined;
     static attemptRequestFullFill(registerId: string): boolean;
 }

package/Tasks/WorldGeneration/WorldGenRegister.js

@@ -1,10 +1,10 @@
 import { WorldSpaces } from "../../World/WorldSpaces.js";
 import { BrushTool } from "../../Tools/Brush/Brush";
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor";
 import { WorldRegister } from "../../World/WorldRegister";
 const brush = new BrushTool();
 const dataTool = brush.voxelCursor;
 export class WorldGenRegister {
+    static _worldThread;
     static MAX_ATTEMPTS = 100;
     static _requests = new Map();
     static registerRequest(location) {
@@ -29,7 +29,12 @@ export class WorldGenRegister {
             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]);
+                this._worldThread.runTask("add-sector", [
+                    requests.dimension,
+                    sectorPos.x,
+                    sectorPos.y,
+                    sectorPos.z,
+                ]);
                 requests.sections.set(sectorKey, [
                     sectorPos.x,
                     sectorPos.y,
@@ -51,7 +56,12 @@ export class WorldGenRegister {
             const sector = WorldRegister.sectors.get(requests.dimension, pos[0], pos[1], pos[2]);
             if (!sector) {
                 done = false;
-                DivineVoxelEngineConstructor.instance.threads.world.runTask("add-sector", [requests.dimension, pos[0], pos[1], pos[2]]);
+                this._worldThread.runTask("add-sector", [
+                    requests.dimension,
+                    pos[0],
+                    pos[1],
+                    pos[2],
+                ]);
             }
         }
         if (!done) {

package/Tasks/WorldGeneration/WorldGeneration.d.ts

@@ -1,12 +1,12 @@
 import { WorldGenRegister } from "./WorldGenRegister.js";
 import { WorldGenBrush } from "./WorldGenBrush.js";
 import { WorldGenInterface } from "./WorldGen.types.js";
-import { GenerateTasks } from "../Tasks.types.js";
+import { LocationData } from "../../Math/index.js";
 export declare class WorldGeneration {
     static worldGen: WorldGenInterface | null;
     static register: typeof WorldGenRegister;
     static _brushes: any[];
     static setWorldGen(worldGen: WorldGenInterface): void;
-    static generate(data: GenerateTasks, mode: "generate" | "decorate", onDone: Function): Promise<void>;
+    static generate(data: Readonly<LocationData>, mode: "generate" | "decorate", onDone: Function): Promise<void>;
     static getBrush(): WorldGenBrush;
 }

package/Tasks/WorldGeneration/WorldGeneration.js

@@ -3,6 +3,8 @@
 import { WorldGenRegister } from "./WorldGenRegister.js";
 //tools
 import { WorldGenBrush } from "./WorldGenBrush.js";
+import { WorldRegister } from "../../World/WorldRegister.js";
+import { Sector } from "../../World/index.js";
 export class WorldGeneration {
     static worldGen = null;
     static register = WorldGenRegister;
@@ -14,19 +16,30 @@ export class WorldGeneration {
         if (!this.worldGen) {
             throw new Error(`A World Generator must be set.`);
         }
-        const requestsId = WorldGenRegister.registerRequest(data[0]);
+        const requestsId = WorldGenRegister.registerRequest(data);
         for (const brush of this._brushes) {
             brush.requestsId = requestsId;
         }
+        const sector = WorldRegister.sectors.get(...data);
+        if (!sector) {
+            console.error(`Error when attempting wolrd gen at [${data.join(",")}] Sector does not exist`);
+            return;
+        }
         if (mode == "generate") {
-            await this.worldGen.generate(data);
+            await this.worldGen.generate(...data);
         }
         if (mode == "decorate") {
-            await this.worldGen.decorate(data);
+            await this.worldGen.decorate(...data);
         }
         if (!WorldGenRegister.attemptRequestFullFill(requestsId)) {
             const readyCheck = () => {
                 if (WorldGenRegister.attemptRequestFullFill(requestsId)) {
+                    if (mode == "generate") {
+                        sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
+                    }
+                    if (mode == "decorate") {
+                        sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
+                    }
                     onDone();
                     return;
                 }
@@ -35,6 +48,12 @@ export class WorldGeneration {
             readyCheck();
         }
         else {
+            if (mode == "generate") {
+                sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
+            }
+            if (mode == "decorate") {
+                sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
+            }
             onDone();
         }
     }

package/Templates/Archive/ArchivedVoxelTemplate.d.ts

@@ -0,0 +1,37 @@
+import { Flat3DIndex, Vec3Array, Vector3Like } from "@amodx/math";
+import { ArchivedVoxelTemplateData } from "./ArchivedVoxelTemplate.types";
+import type { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { NumberPalette } from "../../Util/NumberPalette";
+import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
+import { BinaryBuffer } from "../../Util/BinaryBuffer/index";
+import { VoxelPaletteArchiveReader } from "../../Voxels/Archive/VoxelPaletteArchiveReader";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+type TemplateCursor = {
+    position: Vec3Array;
+    raw: RawVoxelData;
+};
+export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
+    private _data;
+    index: Flat3DIndex;
+    position: Vector3Like;
+    bounds: BoundingBox;
+    ids: BinaryBuffer;
+    level: BinaryBuffer;
+    secondary: BinaryBuffer;
+    voxelPalette: VoxelPaletteArchiveReader;
+    levelPalette: NumberPalette;
+    secondaryPalette: NumberPalette;
+    constructor(_data: ArchivedVoxelTemplateData);
+    setPosition(x: number, y: number, z: number): void;
+    isAir(index: number): boolean;
+    isIncluded(index: number): boolean;
+    getIndex(x: number, y: number, z: number): number;
+    getId(index: number): number;
+    getLevel(index: number): number;
+    getLight(index: number): number;
+    getSecondary(index: number): number;
+    traverse(curosr?: TemplateCursor): Generator<TemplateCursor>;
+    getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    toJSON(): ArchivedVoxelTemplateData;
+}
+export {};

package/Templates/Archive/ArchivedVoxelTemplate.js

@@ -0,0 +1,124 @@
+import { Flat3DIndex } from "@amodx/math";
+import { NumberPalette } from "../../Util/NumberPalette";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelTagsRegister } from "../../Voxels/Data/VoxelTagsRegister";
+import { BinaryBuffer, BinaryBufferFormat, } from "../../Util/BinaryBuffer/index";
+import { VoxelPaletteArchiveReader } from "../../Voxels/Archive/VoxelPaletteArchiveReader";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class ArchivedVoxelTemplate {
+    _data;
+    index = Flat3DIndex.GetXZYOrder();
+    position;
+    bounds;
+    ids;
+    level;
+    secondary;
+    voxelPalette;
+    levelPalette;
+    secondaryPalette;
+    constructor(_data) {
+        this._data = _data;
+        this.bounds = new BoundingBox();
+        this.position = { ..._data.position };
+        this.bounds.setMinPositionAndSize(_data.position, _data.bounds);
+        this.index.setBounds(_data.bounds.x, _data.bounds.y, _data.bounds.z);
+        this.voxelPalette = new VoxelPaletteArchiveReader(_data.palettes);
+        if (_data.palettes.level) {
+            this.levelPalette = new NumberPalette(BinaryBuffer.ToTypedArray(_data.palettes.level));
+        }
+        else {
+            this.levelPalette = new NumberPalette([0]);
+        }
+        if (_data.palettes.secondary) {
+            this.secondaryPalette = new NumberPalette(BinaryBuffer.ToTypedArray(_data.palettes.secondary));
+        }
+        else {
+            this.secondaryPalette = new NumberPalette([0]);
+        }
+        const volume = this.index.size;
+        this.ids = _data.buffers.ids
+            ? new BinaryBuffer(_data.buffers.ids)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: volume,
+                buffer: 0,
+            }));
+        this.level = _data.buffers.level
+            ? new BinaryBuffer(_data.buffers.level)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                byteLength: volume,
+                buffer: 0,
+            }));
+        this.secondary = _data.buffers.secondary
+            ? new BinaryBuffer(_data.buffers.secondary)
+            : new BinaryBuffer(BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: volume,
+                buffer: 0,
+            }));
+    }
+    setPosition(x, y, z) {
+        this.position.x = x;
+        this.position.y = y;
+        this.position.z = z;
+    }
+    isAir(index) {
+        return this.getId(index) === 0;
+    }
+    isIncluded(index) {
+        return true;
+    }
+    getIndex(x, y, z) {
+        return this.index.getIndexXYZ(x, y, z);
+    }
+    getId(index) {
+        return VoxelPalettesRegister.getVoxelIdFromString(...this.voxelPalette.getVoxelData(this.ids.getValue(index)));
+    }
+    getLevel(index) {
+        return this.levelPalette.getValue(this.level.getValue(index));
+    }
+    getLight(index) {
+        return 0;
+    }
+    getSecondary(index) {
+        const id = this.getId(index);
+        const trueId = VoxelPalettesRegister.voxels[id][0];
+        if (VoxelTagsRegister.VoxelTags[trueId]["dve_can_have_secondary"]) {
+            return VoxelPalettesRegister.getVoxelIdFromString(...this.voxelPalette.getVoxelData(this.secondaryPalette.getValue(this.secondary.getValue(index))));
+        }
+        return 0;
+    }
+    *traverse(curosr = {
+        position: [0, 0, 0],
+        raw: [0, 0, 0, 0],
+    }) {
+        for (let x = 0; x < this.bounds.size.x; x++) {
+            for (let y = 0; y < this.bounds.size.y; y++) {
+                for (let z = 0; z < this.bounds.size.z; z++) {
+                    curosr.position[0] = x;
+                    curosr.position[1] = y;
+                    curosr.position[2] = z;
+                    const vindex = this.index.getIndexXYZ(x, y, z);
+                    curosr.raw[0] = this.getId(vindex);
+                    curosr.raw[1] = 0;
+                    curosr.raw[2] = this.getLevel(vindex);
+                    curosr.raw[3] = this.getSecondary(vindex);
+                    if (curosr.raw[0] < 1 && curosr.raw[3] < 1)
+                        continue;
+                    yield curosr;
+                }
+            }
+        }
+    }
+    getRaw(index, rawRef = [0, 0, 0, 0]) {
+        rawRef[0] = this.getId(index);
+        rawRef[1] = this.getLight(index);
+        rawRef[2] = this.getLevel(index);
+        rawRef[3] = this.getSecondary(index);
+        return rawRef;
+    }
+    toJSON() {
+        return this._data;
+    }
+}

package/Templates/Archive/ArchivedVoxelTemplate.types.d.ts

@@ -0,0 +1,45 @@
+import { VoxelArchivePaletteData, VoxelArchiPaveletteExportedJSONData, ArchivedVoxelPaletteDataKey } from "../../Voxels/Archive/VoxelArchive.types";
+import { BinaryBufferData, JSONBinaryBufferData } from "../../Util/BinaryBuffer/BinaryBuffer.types";
+import { IVoxelTemplateData } from "../VoxelTemplates.types";
+import { IndexOrderingTypes } from "../../Math/Indexing";
+export interface ArchivedVoxelTemplateDataKey {
+    voxelPalette: ArchivedVoxelPaletteDataKey;
+    arrayOrders: {
+        id: IndexOrderingTypes;
+        level: IndexOrderingTypes;
+        secondary: IndexOrderingTypes;
+    };
+}
+export interface ArchivedVoxelTemplateBuffers {
+    ids?: BinaryBufferData;
+    level?: BinaryBufferData;
+    secondary?: BinaryBufferData;
+}
+export interface ArchivedVoxelTemplatePaletteData extends VoxelArchivePaletteData {
+    level?: BinaryBufferData;
+    secondary?: BinaryBufferData;
+}
+export interface BaseVoxelTemplateData extends IVoxelTemplateData<"archived"> {
+    /** A user provided version of the data. */
+    formatVersion: string;
+    /** The version of vlox the data was stored in. */
+    engineVersion: string;
+    dataKey: ArchivedVoxelTemplateDataKey;
+}
+export interface ArchivedVoxelTemplateData extends BaseVoxelTemplateData {
+    palettes: ArchivedVoxelTemplatePaletteData;
+    buffers: ArchivedVoxelTemplateBuffers;
+}
+export interface ArchivedVoxelTemplatePaletteDataExportedJSONData extends VoxelArchiPaveletteExportedJSONData {
+    level?: JSONBinaryBufferData;
+    secondary?: JSONBinaryBufferData;
+}
+export interface ArchivedVoxelTemplateBuffersExportdJSONData {
+    ids?: JSONBinaryBufferData;
+    level?: JSONBinaryBufferData;
+    secondary?: JSONBinaryBufferData;
+}
+export interface ArchivedVoxelTemplateExportedJSONData extends BaseVoxelTemplateData {
+    palettes: ArchivedVoxelTemplatePaletteDataExportedJSONData;
+    buffers: ArchivedVoxelTemplateBuffersExportdJSONData;
+}

package/Templates/Archive/ArchivedVoxelTemplate.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+import { ArchivedVoxelTemplate } from "../ArchivedVoxelTemplate";
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
+import { BoundsMinMaxData } from "@amodx/math/Geomtry/Bounds/BoundsInterface";
+/**
+ * Creates an archived template using the passed in the data cursor.
+ * @param dimension
+ * @param start
+ * @param end
+ * @returns
+ */
+export default function CreateArchivedTemplate(dataCursor: DataCursorInterface, bounds: BoundsMinMaxData): ArchivedVoxelTemplate;