@divinevoxel/vlox 0.0.74 → 0.0.75

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;

package/Templates/Archive/Functions/CreateArchivedTemplate.js

@@ -0,0 +1,184 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { ArchivedVoxelTemplate } from "../ArchivedVoxelTemplate";
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { BinaryBuffer, BinaryBufferFormat, } from "../../../Util/BinaryBuffer/index";
+import { VoxelArchivePalette } from "../../../Voxels/Archive/VoxelPaletteArechive";
+import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { EngineSettings } from "../../../Settings/EngineSettings";
+/**
+ * Creates an archived template using the passed in the data cursor.
+ * @param dimension
+ * @param start
+ * @param end
+ * @returns
+ */
+export default function CreateArchivedTemplate(dataCursor, bounds) {
+    const index = Flat3DIndex.GetXZYOrder();
+    index.setBounds(bounds.max.x - bounds.min.x, bounds.max.y - bounds.min.y, bounds.max.z - bounds.min.z);
+    const levelPalette = new NumberPalette();
+    const voxelPalette = new VoxelArchivePalette();
+    const secondaryPalette = new NumberPalette();
+    const ids = new Uint16Array(index.size);
+    const levels = new Uint8Array(index.size);
+    const secondary = new Uint16Array(index.size);
+    let idsAllTheSame = true;
+    let levelAllTheSame = true;
+    let secondaryAllTheSame = true;
+    let firstId = -1;
+    let firstLevel = -1;
+    let firstSecondary = -1;
+    const { x: sx, y: sy, z: sz } = bounds.min;
+    const { x: ex, y: ey, z: ez } = bounds.max;
+    for (let x = sx; x < ex; x++) {
+        for (let y = sy; y < ey; y++) {
+            for (let z = sz; z < ez; z++) {
+                const voxel = dataCursor.getVoxel(x, y, z);
+                if (!voxel)
+                    continue;
+                const vindex = index.getIndexXYZ(x - sx, y - sy, z - sz);
+                const rawData = voxel.getRaw();
+                const level = rawData[2];
+                const voxelId = voxelPalette.register(rawData[0]);
+                const levelId = !levelPalette.isRegistered(level)
+                    ? levelPalette.register(level)
+                    : levelPalette.getId(level);
+                let voxelSecondary = 0;
+                if (VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxels[rawData[0]][0]]["dve_can_have_secondary"]) {
+                    voxelSecondary = voxelPalette.register(rawData[3]);
+                    if (!secondaryPalette.isRegistered(voxelSecondary))
+                        secondaryPalette.register(voxelSecondary);
+                }
+                if (firstId == -1)
+                    firstId = voxelId;
+                if (firstLevel == -1)
+                    firstLevel = levelId;
+                if (firstSecondary == -1)
+                    firstSecondary = voxelSecondary;
+                ids[vindex] = voxelId;
+                levels[vindex] = levelId;
+                secondary[vindex] = voxelSecondary;
+                if (firstId != voxelId)
+                    idsAllTheSame = false;
+                if (firstLevel != levelId)
+                    levelAllTheSame = false;
+                if (firstSecondary != voxelSecondary)
+                    secondaryAllTheSame = false;
+            }
+        }
+    }
+    const buffers = {};
+    const idsPaletted = voxelPalette.size < 0xffff;
+    const levelPaletted = levelPalette.size < 0xff;
+    const secondaryPaletted = secondaryPalette.size < 0xffff;
+    //id
+    if (idsAllTheSame) {
+        if (firstId !== 0) {
+            buffers.ids = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: ids.length,
+                buffer: ids[0],
+            });
+        }
+    }
+    else if (idsPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(voxelPalette.size);
+        buffers.ids = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(ids, BinaryBufferFormat.Uint16, type).buffer,
+            format: type,
+            byteLength: ids.length,
+        });
+    }
+    else {
+        buffers.ids = BinaryBuffer.Create({
+            buffer: ids.buffer,
+            format: BinaryBufferFormat.Uint16,
+            byteLength: ids.length,
+        });
+    }
+    //levelPaletted
+    if (levelAllTheSame) {
+        if (firstId !== 0) {
+            buffers.level = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                byteLength: levels.length,
+                buffer: levels[0],
+            });
+        }
+    }
+    else if (levelPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(levelPalette.size);
+        buffers.level = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(levels, BinaryBufferFormat.Uint8, type)
+                .buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.level = BinaryBuffer.Create({
+            buffer: levels.buffer,
+            format: BinaryBufferFormat.Uint8,
+        });
+    }
+    //secondary
+    if (secondaryAllTheSame) {
+        if (firstId !== 0) {
+            buffers.secondary = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: secondary.length,
+                buffer: secondary[0],
+            });
+        }
+    }
+    else if (secondaryPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(voxelPalette.size);
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(secondary, BinaryBufferFormat.Uint16, type)
+                .buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: secondary.buffer,
+            format: BinaryBufferFormat.Uint16,
+        });
+    }
+    const palettes = {
+        ...voxelPalette.toJSON(),
+    };
+    if (!(levelPalette.size == 1 && levelPalette._palette[0] === 0)) {
+        palettes.level = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint8,
+            byteLength: levelPalette._palette.length,
+            buffer: Uint8Array.from(levelPalette._palette).buffer,
+        });
+    }
+    if (!(secondaryPalette.size == 1 && secondaryPalette._palette[0] === 0)) {
+        palettes.secondary = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint16,
+            byteLength: secondaryPalette._palette.length,
+            buffer: Uint16Array.from(secondaryPalette._palette).buffer,
+        });
+    }
+    const data = {
+        type: "archived",
+        engineVersion: EngineSettings.version,
+        formatVersion: "",
+        dataKey: {
+            voxelPalette: VoxelArchivePalette.GetVoxelPaletteDataKey(),
+            arrayOrders: {
+                id: "YXZ",
+                level: "YXZ",
+                secondary: "YXZ",
+            },
+        },
+        position: Vector3Like.Create(),
+        bounds: Vector3Like.Create(...index.getBounds()),
+        palettes,
+        buffers,
+    };
+    console.log(data);
+    const archived = new ArchivedVoxelTemplate(data);
+    return archived;
+}

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

@@ -0,0 +1,2 @@
+import { ArchivedVoxelTemplateData, ArchivedVoxelTemplateExportedJSONData } from "../ArchivedVoxelTemplate.types";
+export default function ExportArchiedTemplateJSON(templateData: ArchivedVoxelTemplateData): Promise<ArchivedVoxelTemplateExportedJSONData>;

package/Templates/Archive/Functions/ExportArchiedTemplateJSON.js

@@ -0,0 +1,44 @@
+import { BinaryBuffer, BinaryBufferFormat, } from "../../../Util/BinaryBuffer/index";
+export default async function ExportArchiedTemplateJSON(templateData) {
+    const buffers = {
+        ids: templateData.buffers.ids
+            ? await BinaryBuffer.ToJSON(templateData.buffers.ids, true)
+            : undefined,
+        secondary: templateData.buffers.secondary
+            ? await BinaryBuffer.ToJSON(templateData.buffers.secondary, true)
+            : undefined,
+        level: templateData.buffers.level
+            ? await BinaryBuffer.ToJSON(templateData.buffers.level, true)
+            : undefined,
+    };
+    const palettes = {
+        voxels: templateData.palettes.voxels,
+        stateSchemas: templateData.palettes.stateSchemas,
+        voxelPalette: await BinaryBuffer.ToJSON(BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint16,
+            buffer: templateData.palettes.voxelPalette.buffer,
+        })),
+    };
+    if (templateData.palettes.secondary) {
+        palettes.secondary = await BinaryBuffer.ToJSON(BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint16,
+            buffer: templateData.palettes.secondary.buffer,
+        }));
+    }
+    if (templateData.palettes.level) {
+        palettes.level = await BinaryBuffer.ToJSON(BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint8,
+            buffer: templateData.palettes.level.buffer,
+        }));
+    }
+    return {
+        engineVersion: templateData.engineVersion,
+        formatVersion: templateData.formatVersion,
+        dataKey: templateData.dataKey,
+        position: templateData.position,
+        bounds: templateData.bounds,
+        type: templateData.type,
+        buffers,
+        palettes,
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { ArchivedVoxelTemplateData, ArchivedVoxelTemplateExportedJSONData } from "../ArchivedVoxelTemplate.types";
+export default function ImportArchivedTemplateJSON(jsonData: ArchivedVoxelTemplateExportedJSONData): Promise<ArchivedVoxelTemplateData>;

package/Templates/Archive/Functions/ImportArchivedTemplateJSON.js

@@ -0,0 +1,37 @@
+import { BinaryBuffer } from "../../../Util/BinaryBuffer/BinaryBuffer";
+export default async function ImportArchivedTemplateJSON(jsonData) {
+    const buffers = {
+        ids: jsonData.buffers.ids
+            ? await BinaryBuffer.FromJSON(jsonData.buffers.ids)
+            : undefined,
+        level: jsonData.buffers.level
+            ? await BinaryBuffer.FromJSON(jsonData.buffers.level)
+            : undefined,
+        secondary: jsonData.buffers.secondary
+            ? await BinaryBuffer.FromJSON(jsonData.buffers.secondary)
+            : undefined,
+    };
+    const palettes = {
+        voxels: jsonData.palettes.voxels,
+        stateSchemas: jsonData.palettes.stateSchemas,
+        voxelPalette: await BinaryBuffer.FromJSON(jsonData.palettes.voxelPalette),
+    };
+    if (jsonData.palettes.secondary) {
+        palettes.secondary = await BinaryBuffer.FromJSON(jsonData.palettes.secondary);
+    }
+    if (jsonData.palettes.level) {
+        palettes.level = await BinaryBuffer.FromJSON(jsonData.palettes.level);
+    }
+    const data = {
+        engineVersion: jsonData.engineVersion,
+        formatVersion: jsonData.formatVersion,
+        dataKey: jsonData.dataKey,
+        type: jsonData.type,
+        position: jsonData.position,
+        bounds: jsonData.bounds,
+        buffers,
+        palettes,
+    };
+    console.warn("IMPORT TEMPLATE", data, jsonData);
+    return data;
+}

package/Templates/Cursor/TemplateCursor.d.ts

@@ -1,11 +1,13 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
-import { FullVoxelTemplate } from "Templates/FullVoxelTemplate";
+import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
+import { TemplateProxy } from "./TemplateProxy";
 export declare class TemplateCursor implements DataCursorInterface {
     _voxelIndex: number;
-    _template: FullVoxelTemplate | null;
+    _proxy: TemplateProxy | null;
     private voxel;
     inBounds(x: number, y: number, z: number): boolean;
-    setTemplate(template: FullVoxelTemplate): void;
+    setTemplate(template: IVoxelTemplate): void;
     getVoxel(x: number, y: number, z: number): TemplateVoxelCursor | null;
+    clone(): DataCursorInterface;
 }

package/Templates/Cursor/TemplateCursor.js

@@ -1,19 +1,23 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
+import { TemplateProxy } from "./TemplateProxy";
 export class TemplateCursor {
     _voxelIndex = 0;
-    _template = null;
+    _proxy = null;
     voxel = new TemplateVoxelCursor(this);
     inBounds(x, y, z) {
         return true;
     }
     setTemplate(template) {
-        this._template = template;
+        this._proxy = new TemplateProxy(template);
     }
     getVoxel(x, y, z) {
-        if (!this._template)
+        if (!this._proxy)
             return null;
-        this._voxelIndex = this._template.index.getIndexXYZ(x, y, z);
+        this._voxelIndex = this._proxy.template.index.getIndexXYZ(x, y, z);
         this.voxel.loadIn();
         return this.voxel;
     }
+    clone() {
+        return new TemplateCursor();
+    }
 }

package/Templates/Cursor/TemplateProxy.d.ts

@@ -0,0 +1,10 @@
+import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
+import { NumberArray } from "../../Util/Util.types";
+export declare class TemplateProxy {
+    template: IVoxelTemplate;
+    ids: NumberArray;
+    levels: NumberArray;
+    secondary: NumberArray;
+    light: NumberArray;
+    constructor(template: IVoxelTemplate);
+}

package/Templates/Cursor/TemplateProxy.js

@@ -0,0 +1,22 @@
+export class TemplateProxy {
+    template;
+    ids;
+    levels;
+    secondary;
+    light;
+    constructor(template) {
+        this.template = template;
+        this.ids = new Proxy([], {
+            get: (_, index) => this.template.getId(Number(index)),
+        });
+        this.light = new Proxy([], {
+            get: (_, index) => this.template.getLight(Number(index)),
+        });
+        this.levels = new Proxy([], {
+            get: (_, index) => this.template.getLevel(Number(index)),
+        });
+        this.secondary = new Proxy([], {
+            get: (_, index) => this.template.getSecondary(Number(index)),
+        });
+    }
+}

package/Templates/Cursor/TemplateVoxelCursor.d.ts

@@ -2,13 +2,11 @@ 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;
-    get mod(): Uint16Array;
+    private _proxy;
+    get ids(): import("../../Util/Util.types").NumberArray;
+    get level(): import("../../Util/Util.types").NumberArray;
+    get light(): import("../../Util/Util.types").NumberArray;
+    get secondary(): import("../../Util/Util.types").NumberArray;
     constructor(dataCursor: TemplateCursor);
     loadIn(): void;
     updateVoxel(mode: 0 | 1): void;

package/Templates/Cursor/TemplateVoxelCursor.js

@@ -1,33 +1,27 @@
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export class TemplateVoxelCursor extends VoxelCursorInterface {
     dataCursor;
-    _template;
+    _proxy;
     get ids() {
-        return this._template.ids;
+        return this._proxy.ids;
     }
     get level() {
-        return this._template.level;
+        return this._proxy.levels;
     }
     get light() {
-        return this._template.light;
-    }
-    get state() {
-        return this._template.state;
+        return this._proxy.light;
     }
     get secondary() {
-        return this._template.secondary;
-    }
-    get mod() {
-        return this._template.mod;
+        return this._proxy.secondary;
     }
     constructor(dataCursor) {
         super();
         this.dataCursor = dataCursor;
     }
     loadIn() {
-        if (!this.dataCursor._template)
+        if (!this.dataCursor._proxy)
             return;
-        this._template = this.dataCursor._template;
+        this._proxy = this.dataCursor._proxy;
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }

package/Templates/Full/FullVoxelTemplate.d.ts

@@ -0,0 +1,27 @@
+import { Flat3DIndex, Vec3Array, Vector3Like } from "@amodx/math";
+import { IVoxelTemplate } from "../VoxelTemplates.types";
+import { FullVoxelTemplateData } from "./FullVoxelTemplate.types";
+import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export declare class FullVoxelTemplate implements IVoxelTemplate {
+    static CreateNew(bounds: Vec3Array, baseLightValue?: number): FullVoxelTemplateData;
+    index: Flat3DIndex;
+    position: Vector3Like;
+    bounds: BoundingBox;
+    ids: Uint16Array;
+    level: Uint8Array;
+    light: Uint16Array;
+    secondary: Uint16Array;
+    mask?: Uint8Array;
+    constructor(data: FullVoxelTemplateData);
+    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;
+    getLight(index: number): number;
+    getLevel(index: number): number;
+    getSecondary(index: number): number;
+    getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    toJSON(): FullVoxelTemplateData;
+}