@divinevoxel/vlox 0.0.73 → 0.0.75

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;
+}

package/Templates/Full/FullVoxelTemplate.js

@@ -0,0 +1,108 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { getBitArrayIndex } from "../../Util/Binary/BinaryArrays";
+import { EngineSettings } from "../../Settings/EngineSettings";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class FullVoxelTemplate {
+    static CreateNew(bounds, baseLightValue = 0) {
+        const voxelSize = bounds[0] * bounds[1] * bounds[2];
+        const bufferSize = //ids
+         voxelSize * 2 +
+            //light
+            voxelSize * 2 +
+            //secondary
+            voxelSize * 2 +
+            //level
+            voxelSize;
+        const sectionBuffer = EngineSettings.settings.memoryAndCPU.useSharedMemory
+            ? new SharedArrayBuffer(bufferSize)
+            : new ArrayBuffer(bufferSize);
+        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 secondary = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const level = new Uint8Array(sectionBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize;
+        return {
+            type: "full",
+            position: Vector3Like.Create(),
+            bounds: Vector3Like.Create(...bounds),
+            ids,
+            light,
+            level,
+            secondary,
+        };
+    }
+    index = Flat3DIndex.GetXZYOrder();
+    position = Vector3Like.Create();
+    bounds;
+    ids;
+    level;
+    light;
+    secondary;
+    mask;
+    constructor(data) {
+        this.position = { ...data.position };
+        this.bounds = new BoundingBox();
+        this.bounds.setMinPositionAndSize(data.position, data.bounds);
+        this.index.setBounds(data.bounds.x, data.bounds.y, data.bounds.z);
+        this.ids = data.ids;
+        this.level = data.level;
+        this.light = data.light;
+        this.secondary = data.secondary;
+        if (data.mask)
+            this.mask = data.mask;
+    }
+    setPosition(x, y, z) {
+        this.position.x = x;
+        this.position.y = y;
+        this.position.z = z;
+    }
+    isAir(index) {
+        return this.ids[index] === 0;
+    }
+    isIncluded(index) {
+        if (this.mask) {
+            return getBitArrayIndex(this.mask, index) === 1;
+        }
+        return true;
+    }
+    getIndex(x, y, z) {
+        return this.index.getIndexXYZ(x, y, z);
+    }
+    getId(index) {
+        return this.ids[index];
+    }
+    getLight(index) {
+        return this.light[index];
+    }
+    getLevel(index) {
+        return this.level[index];
+    }
+    getSecondary(index) {
+        return this.secondary[index];
+    }
+    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 {
+            type: "full",
+            position: this.position,
+            bounds: this.bounds.size,
+            ids: this.ids,
+            light: this.light,
+            level: this.level,
+            secondary: this.secondary,
+            ...(this.mask ? { mask: this.mask } : {}),
+        };
+    }
+}

package/Templates/Full/FullVoxelTemplate.types.d.ts

@@ -0,0 +1,5 @@
+import { VoxelDataArrays } from "../../Voxels";
+import { IVoxelTemplateData } from "../VoxelTemplates.types";
+export interface FullVoxelTemplateData extends IVoxelTemplateData<"full">, VoxelDataArrays {
+    mask?: Uint8Array;
+}

package/Templates/Full/FullVoxelTemplate.types.js

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

package/Templates/Full/Functions/CreateFullTemplate.d.ts

@@ -0,0 +1,3 @@
+import { BoundsMinMaxData } from "@amodx/math/Geomtry/Bounds/BoundsInterface";
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
+export default function CreateFullTemplate(dataCursor: DataCursorInterface, bounds: BoundsMinMaxData, storeLight?: boolean): import("../FullVoxelTemplate.types").FullVoxelTemplateData;

package/Templates/Full/Functions/CreateFullTemplate.js

@@ -0,0 +1,27 @@
+import { FullVoxelTemplate } from "../FullVoxelTemplate";
+import { Flat3DIndex } from "@amodx/math";
+export default function CreateFullTemplate(dataCursor, bounds, storeLight = false) {
+    const { x: sx, y: sy, z: sz } = bounds.min;
+    const { x: ex, y: ey, z: ez } = bounds.max;
+    const template = FullVoxelTemplate.CreateNew([ex - sx, ey - sy, ez - sz]);
+    const index = Flat3DIndex.GetXZYOrder();
+    index.setBounds(template.bounds.x, template.bounds.y, template.bounds.z);
+    for (let x = sx; x < ex; x++) {
+        for (let y = sy; y < ey; y++) {
+            for (let z = sz; z < ez; z++) {
+                if (!dataCursor.inBounds(x, y, z))
+                    continue;
+                const voxel = dataCursor.getVoxel(x, y, z);
+                if (!voxel)
+                    continue;
+                const vIndex = index.getIndexXYZ(x - sx, y - sy, z - sz);
+                template.ids[vIndex] = voxel.ids[voxel._index];
+                template.level[vIndex] = voxel.level[voxel._index];
+                template.secondary[vIndex] = voxel.secondary[voxel._index];
+                if (storeLight)
+                    template.light[vIndex] = voxel.light[voxel._index];
+            }
+        }
+    }
+    return template;
+}

package/Templates/Functions/FlipTemplate.d.ts

@@ -1,3 +1,3 @@
-import { VoxelTemplate } from "../VoxelTemplate";
+import { FullVoxelTemplate } from "../../Templates/Full/FullVoxelTemplate";
 export type TemplateFlipDirections = "x" | "z" | "y";
-export default function FlipTemplate(template: VoxelTemplate, direction: TemplateFlipDirections): void;
+export default function FlipTemplate(template: FullVoxelTemplate, direction: TemplateFlipDirections): void;

package/Templates/Functions/FlipTemplate.js

@@ -25,7 +25,7 @@ const flipArray = ([sizeX, sizeY, sizeZ], array, direction, index) => {
     }
 };
 export default function FlipTemplate(template, direction) {
-    const [sizeX, sizeY, sizeZ] = template.size;
+    const { x: sizeX, y: sizeY, z: sizeZ } = template.bounds.size;
     const index = Flat3DIndex.GetXZYOrder();
     index.setBounds(sizeX, sizeY, sizeZ);
     if (typeof template.ids === "object") {
@@ -36,14 +36,6 @@ export default function FlipTemplate(template, direction) {
         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);
-    }
-    if (typeof template.mod === "object") {
-        const mod = template.mod;
-        flipArray([sizeX, sizeY, sizeZ], mod, direction, index);
-    }
     if (typeof template.secondary === "object") {
         const secondary = template.secondary;
         flipArray([sizeX, sizeY, sizeZ], secondary, direction, index);

package/Templates/Functions/RotateTemplate.d.ts

@@ -1,4 +1,4 @@
-import { VoxelTemplate } from "../VoxelTemplate";
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
 export type TemplateRotationAxes = "x" | "y" | "z";
 export type TemplateRotationAngles = 90 | 180 | 270 | -90 | -180 | -270;
-export default function RotateTemplate(template: VoxelTemplate, angle: TemplateRotationAngles, axes?: TemplateRotationAxes): void;
+export default function RotateTemplate(template: FullVoxelTemplate, angle: TemplateRotationAngles, axes?: TemplateRotationAxes): void;

package/Templates/Functions/RotateTemplate.js

@@ -66,7 +66,7 @@ const rotateArray = ([sizeX, sizeY, sizeZ], array, angle, axes, index, newIndex)
     }
 };
 export default function RotateTemplate(template, angle, axes = "y") {
-    const [sizeX, sizeY, sizeZ] = template.size;
+    const { x: sizeX, y: sizeY, z: sizeZ } = template.bounds.size;
     const index = Flat3DIndex.GetXZYOrder();
     index.setBounds(sizeX, sizeY, sizeZ);
     let newSizeX = sizeX;
@@ -97,18 +97,10 @@ export default function RotateTemplate(template, angle, axes = "y") {
         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);
-    }
-    if (typeof template.mod === "object") {
-        const mod = template.mod;
-        rotateArray([sizeX, sizeY, sizeZ], mod, angle, axes, index, newIndex);
-    }
     if (typeof template.secondary === "object") {
         const secondary = template.secondary;
         rotateArray([sizeX, sizeY, sizeZ], secondary, angle, axes, index, newIndex);
     }
     template.index = newIndex;
-    template.size = [newSizeX, newSizeY, newSizeZ];
+    template.bounds.setSize({ x: newSizeX, y: newSizeY, z: newSizeZ });
 }