@divinevoxel/vlox 0.0.76 → 0.0.77

package/Tasks/Paint/Erase/EraseVoxelSelection.js

@@ -0,0 +1,33 @@
+import { VoxelUpdateTask } from "../../VoxelUpdateTask";
+import { canUpdate, updateArea } from "../Common";
+import { VoxelTemplateRegister } from "../../../Templates/VoxelTemplateRegister";
+const tasks = new VoxelUpdateTask();
+export default function EraseVoxelSelection(dimension, [ox, oy, oz], selectionData, updateData) {
+    const selection = VoxelTemplateRegister.createSelection(selectionData);
+    tasks.setOriginAt([dimension, ox, oy, oz]);
+    const { x: sx, y: sy, z: sz } = selection.bounds.size;
+    for (let x = 0; x < sx; x++) {
+        for (let y = 0; y < sy; y++) {
+            for (let z = 0; z < sz; z++) {
+                const tx = ox + x;
+                const ty = oy + y;
+                const tz = oz + z;
+                if (!selection.isSelected(tx, ty, tz))
+                    continue;
+                if (!canUpdate(tx, ty, tz, updateData))
+                    continue;
+                if (!tasks.sDataCursor.inBounds(tx, ty, tz))
+                    continue;
+                const voxel = tasks.sDataCursor.getVoxel(tx, ty, tz);
+                if (!voxel || voxel.isAir())
+                    continue;
+                voxel.ids[voxel._index] = 0;
+                voxel.level[voxel._index] = 0;
+                voxel.secondary[voxel._index] = 0;
+                voxel.light[voxel._index] = 0;
+                voxel.updateVoxel(1);
+            }
+        }
+    }
+    updateArea(tasks, ox, oy, oz, ox + sx, oy + sy, oz + sz);
+}

package/Tasks/Paint/Erase/EraseVoxelTemplate.js

@@ -1,8 +1,7 @@
 import { VoxelUpdateTask } from "../../VoxelUpdateTask";
 import { canUpdate, updateArea } from "../Common";
-import { VoxelTemplateRegister } from "../../../Templates/VoxelTempateRegister";
+import { VoxelTemplateRegister } from "../../../Templates/VoxelTemplateRegister";
 const tasks = new VoxelUpdateTask();
-const raw = [0, 0, 0, 0];
 export default function EraseVoxelTemplate(dimension, [ox, oy, oz], templateData, updateData) {
     const voxelTemplate = VoxelTemplateRegister.create(templateData);
     tasks.setOriginAt([dimension, ox, oy, oz]);

package/Tasks/Paint/Paint/PaintVoxel.js

@@ -15,7 +15,7 @@ export function PaintVoxel(location, raw, updateData) {
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     voxel.setRaw(raw);
     voxel.updateVoxel(0);
-    updateArea(tasks, x - 1, y - 1, z - 1, x + 1, y + 1, z + 1);
+    updateArea(tasks, x, y, z, x, y, z);
     if (ES.doPower) {
         if (voxel.tags["dve_can_be_powered"] ||
             voxel.tags["dve_is_power_source"] ||

package/Tasks/Paint/Paint/PaintVoxelTemplate.js

@@ -1,6 +1,6 @@
 import { VoxelUpdateTask } from "../../VoxelUpdateTask";
 import { canUpdate, updateArea } from "../Common";
-import { VoxelTemplateRegister } from "../../../Templates/VoxelTempateRegister";
+import { VoxelTemplateRegister } from "../../../Templates/VoxelTemplateRegister";
 const tasks = new VoxelUpdateTask();
 const raw = [0, 0, 0, 0];
 export default function PaintVoxelTemplate(dimension, [ox, oy, oz], templateData, updateData) {

package/Tasks/Propagation/Illumanation/RGBUpdate.js

@@ -35,7 +35,7 @@ export function RGBRemove(tasks) {
     const remove = tasks.rgb.remove;
     const update = tasks.rgb.update;
     const removeMap = tasks.rgb.removeMap;
-    const updateMap = tasks.sun.updateMap;
+    const updateMap = tasks.rgb.updateMap;
     while (remove.length) {
         const x = remove.shift();
         const y = remove.shift();

package/Tasks/Tasks.types.d.ts

@@ -5,6 +5,7 @@ import type EraseVoxelTemplate from "./Paint/Erase/EraseVoxelTemplate.js";
 import type EraseVoxelPath from "./Paint/Erase/EraseVoxelPath.js";
 import { PaintVoxel } from "./Paint/Paint/PaintVoxel.js";
 import PaintVoxelTemplate from "./Paint/Paint/PaintVoxelTemplate.js";
+import EraseVoxelSelection from "./Paint/Erase/EraseVoxelSelection.js";
 export type VoxelUpdateData = {
     /**An array of allowed areas to update in. If not set will be ignored.*/
     includedAreas?: [min: Vec3Array, max: Vec3Array][];
@@ -23,6 +24,7 @@ export type PaintVoxelPathTask = [
 ];
 export type EraseVoxelTask = Parameters<typeof EraseVoxel>;
 export type EraseVoxelTemplateTask = Parameters<typeof EraseVoxelTemplate>;
+export type EraseVoxelSelectionTask = Parameters<typeof EraseVoxelSelection>;
 export type EraseVoxelPathTask = Parameters<typeof EraseVoxelPath>;
 export type WorldLockTasks = [
     dimension: number,

package/Tasks/TasksIds.d.ts

@@ -11,5 +11,6 @@ export declare enum TasksIds {
     PaintVoxelPath = "PaintVoxelPath",
     EraseVoxel = "EraseVoxel",
     EraseVoxelTemplate = "EraseVoxelTemplate",
+    EraseVoxelSelection = "EraseVoxelSelection",
     EraseVoxelPath = "EraseVoxelPath"
 }

package/Tasks/TasksIds.js

@@ -12,5 +12,6 @@ export var TasksIds;
     TasksIds["PaintVoxelPath"] = "PaintVoxelPath";
     TasksIds["EraseVoxel"] = "EraseVoxel";
     TasksIds["EraseVoxelTemplate"] = "EraseVoxelTemplate";
+    TasksIds["EraseVoxelSelection"] = "EraseVoxelSelection";
     TasksIds["EraseVoxelPath"] = "EraseVoxelPath";
 })(TasksIds || (TasksIds = {}));

package/Tasks/WorldGeneration/InitTasks.js

@@ -6,5 +6,7 @@ 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)));
+    Threads.registerBinaryTask(TasksIds.Decorate, (data) => new Promise((resolve) => {
+        WorldGeneration.generate(getLocationData(data), "decorate", resolve);
+    }));
 }

package/Templates/Archive/ArchivedVoxelTemplate.d.ts

@@ -1,4 +1,4 @@
-import { Flat3DIndex, Vec3Array, Vector3Like } from "@amodx/math";
+import { Flat3DIndex, Vec3Array } from "@amodx/math";
 import { ArchivedVoxelTemplateData } from "./ArchivedVoxelTemplate.types";
 import type { RawVoxelData } from "../../Voxels/Types/Voxel.types";
 import { NumberPalette } from "../../Util/NumberPalette";
@@ -11,9 +11,7 @@ type TemplateCursor = {
     raw: RawVoxelData;
 };
 export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
-    private _data;
     index: Flat3DIndex;
-    position: Vector3Like;
     bounds: BoundingBox;
     ids: BinaryBuffer;
     level: BinaryBuffer;
@@ -21,8 +19,9 @@ export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
     voxelPalette: VoxelPaletteArchiveReader;
     levelPalette: NumberPalette;
     secondaryPalette: NumberPalette;
-    constructor(_data: ArchivedVoxelTemplateData);
-    setPosition(x: number, y: number, z: number): void;
+    private data;
+    constructor(data: ArchivedVoxelTemplateData);
+    inBounds(x: number, y: number, z: number): boolean;
     isAir(index: number): boolean;
     isIncluded(index: number): boolean;
     getIndex(x: number, y: number, z: number): number;
@@ -34,5 +33,6 @@ export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
     clone(): ArchivedVoxelTemplate;
     getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
     toJSON(): ArchivedVoxelTemplateData;
+    fromJSON(data: ArchivedVoxelTemplateData): void;
 }
 export {};

package/Templates/Archive/ArchivedVoxelTemplate.js

@@ -1,14 +1,13 @@
-import { Flat3DIndex } from "@amodx/math";
+import { Flat3DIndex, Vector3Like } 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";
+const point = Vector3Like.Create();
 export class ArchivedVoxelTemplate {
-    _data;
     index = Flat3DIndex.GetXZYOrder();
-    position;
     bounds;
     ids;
     level;
@@ -16,52 +15,15 @@ export class ArchivedVoxelTemplate {
     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,
-            }));
+    data;
+    constructor(data) {
+        this.fromJSON(data);
     }
-    setPosition(x, y, z) {
-        this.position.x = x;
-        this.position.y = y;
-        this.position.z = z;
+    inBounds(x, y, z) {
+        point.x = x + 0.5;
+        point.y = y + 0.5;
+        point.z = z + 0.5;
+        return this.bounds.intersectsPoint(point);
     }
     isAir(index) {
         return this.getId(index) === 0;
@@ -123,6 +85,47 @@ export class ArchivedVoxelTemplate {
         return rawRef;
     }
     toJSON() {
-        return this._data;
+        return this.data;
+    }
+    fromJSON(data) {
+        this.data = data;
+        this.bounds = new BoundingBox();
+        this.bounds.setSize(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,
+            }));
     }
 }

package/Templates/Archive/Functions/CreateArchivedTemplate.js

@@ -175,12 +175,10 @@ export default function CreateArchivedTemplate(dataCursor, bounds) {
                 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.js

@@ -35,7 +35,6 @@ export default async function ExportArchiedTemplateJSON(templateData) {
         engineVersion: templateData.engineVersion,
         formatVersion: templateData.formatVersion,
         dataKey: templateData.dataKey,
-        position: templateData.position,
         bounds: templateData.bounds,
         type: templateData.type,
         buffers,

package/Templates/Archive/Functions/ImportArchivedTemplateJSON.js

@@ -27,11 +27,9 @@ export default async function ImportArchivedTemplateJSON(jsonData) {
         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

@@ -2,12 +2,17 @@ import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
 import { TemplateProxy } from "./TemplateProxy";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class TemplateCursor implements DataCursorInterface {
     _voxelIndex: number;
     _proxy: TemplateProxy | null;
+    private _airCursor;
+    baseLightValue: number;
     private voxel;
+    volumeBounds: BoundingBox;
+    constructor();
     inBounds(x: number, y: number, z: number): boolean;
     setTemplate(template: IVoxelTemplate): void;
-    getVoxel(x: number, y: number, z: number): TemplateVoxelCursor | null;
+    getVoxel(x: number, y: number, z: number): TemplateVoxelCursor;
     clone(): DataCursorInterface;
 }

package/Templates/Cursor/TemplateCursor.js

@@ -1,9 +1,16 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
 import { TemplateProxy } from "./TemplateProxy";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const raw = [0, 0, 0, 0];
 export class TemplateCursor {
     _voxelIndex = 0;
     _proxy = null;
+    _airCursor = new VoxelCursor();
+    baseLightValue = 0xf;
     voxel = new TemplateVoxelCursor(this);
+    volumeBounds = new BoundingBox();
+    constructor() { }
     inBounds(x, y, z) {
         if (!this._proxy)
             return false;
@@ -11,10 +18,14 @@ export class TemplateCursor {
     }
     setTemplate(template) {
         this._proxy = new TemplateProxy(template);
+        this.volumeBounds.setMinMax(template.bounds.min, template.bounds.max);
     }
     getVoxel(x, y, z) {
-        if (!this._proxy)
-            return null;
+        if (!this._proxy || !this._proxy.inBounds(x, y, z)) {
+            raw[1] = this.baseLightValue;
+            this._airCursor.setRaw(raw);
+            return this._airCursor;
+        }
         this._voxelIndex = this._proxy.template.index.getIndexXYZ(x, y, z);
         this.voxel.loadIn();
         return this.voxel;

package/Templates/Cursor/TemplateProxy.js

@@ -1,5 +1,3 @@
-import { Vector3Like } from "@amodx/math";
-const point = Vector3Like.Create();
 export class TemplateProxy {
     template;
     ids;
@@ -22,10 +20,7 @@ export class TemplateProxy {
         });
     }
     inBounds(x, y, z) {
-        point.x = x;
-        point.y = y;
-        point.z = z;
-        const inBounds = this.template.bounds.intersectsPoint(point);
+        const inBounds = this.template.inBounds(x, y, z);
         if (!inBounds)
             return false;
         const index = this.template.getIndex(x, y, z);

package/Templates/Cursor/TemplateVoxelCursor.d.ts

@@ -9,5 +9,6 @@ export declare class TemplateVoxelCursor extends VoxelCursorInterface {
     get secondary(): import("../../Util/Util.types").NumberArray;
     constructor(dataCursor: TemplateCursor);
     loadIn(): void;
+    getLight(): number;
     updateVoxel(mode: 0 | 1): void;
 }

package/Templates/Cursor/TemplateVoxelCursor.js

@@ -25,5 +25,11 @@ export class TemplateVoxelCursor extends VoxelCursorInterface {
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }
+    getLight() {
+        const light = super.getLight();
+        if (light <= 0)
+            return this.dataCursor.baseLightValue;
+        return light;
+    }
     updateVoxel(mode) { }
 }

package/Templates/Full/FullVoxelTemplate.d.ts

@@ -1,12 +1,11 @@
-import { Flat3DIndex, Vec3Array, Vector3Like } from "@amodx/math";
+import { Flat3DIndex, Vec3Array } 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 {
+export declare class FullVoxelTemplate implements IVoxelTemplate<"full"> {
     static CreateNew(bounds: Vec3Array, baseLightValue?: number): FullVoxelTemplateData;
     index: Flat3DIndex;
-    position: Vector3Like;
     bounds: BoundingBox;
     ids: Uint16Array;
     level: Uint8Array;
@@ -14,7 +13,7 @@ export declare class FullVoxelTemplate implements IVoxelTemplate {
     secondary: Uint16Array;
     mask?: Uint8Array;
     constructor(data: FullVoxelTemplateData);
-    setPosition(x: number, y: number, z: number): void;
+    inBounds(x: number, y: number, z: number): boolean;
     isAir(index: number): boolean;
     isIncluded(index: number): boolean;
     getIndex(x: number, y: number, z: number): number;
@@ -25,4 +24,5 @@ export declare class FullVoxelTemplate implements IVoxelTemplate {
     getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
     clone(): FullVoxelTemplate;
     toJSON(): FullVoxelTemplateData;
+    fromJSON(data: FullVoxelTemplateData): void;
 }

package/Templates/Full/FullVoxelTemplate.js

@@ -2,6 +2,7 @@ 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";
+const point = Vector3Like.Create();
 export class FullVoxelTemplate {
     static CreateNew(bounds, baseLightValue = 0) {
         const voxelSize = bounds[0] * bounds[1] * bounds[2];
@@ -29,7 +30,6 @@ export class FullVoxelTemplate {
         bufferStart += voxelSize;
         return {
             type: "full",
-            position: Vector3Like.Create(),
             bounds: Vector3Like.Create(...bounds),
             ids,
             light,
@@ -38,7 +38,6 @@ export class FullVoxelTemplate {
         };
     }
     index = Flat3DIndex.GetXZYOrder();
-    position = Vector3Like.Create();
     bounds;
     ids;
     level;
@@ -46,26 +45,20 @@ export class FullVoxelTemplate {
     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;
+        this.fromJSON(data);
     }
-    setPosition(x, y, z) {
-        this.position.x = x;
-        this.position.y = y;
-        this.position.z = z;
+    inBounds(x, y, z) {
+        point.x = x + 0.5;
+        point.y = y + 0.5;
+        point.z = z + 0.5;
+        return this.bounds.intersectsPoint(point);
     }
     isAir(index) {
         return this.ids[index] === 0;
     }
     isIncluded(index) {
+        if (index < 0 || index >= this.index.size)
+            return false;
         if (this.mask) {
             return getBitArrayIndex(this.mask, index) === 1;
         }
@@ -94,13 +87,20 @@ export class FullVoxelTemplate {
         return rawRef;
     }
     clone() {
-        const newTemplate = new FullVoxelTemplate(structuredClone(this.toJSON()));
+        const newTemplate = new FullVoxelTemplate({
+            type: "full",
+            bounds: { ...this.bounds.size },
+            ids: this.ids.slice(),
+            light: this.light.slice(),
+            level: this.level.slice(),
+            secondary: this.secondary.slice(),
+            ...(this.mask ? { mask: this.mask.slice() } : {}),
+        });
         return newTemplate;
     }
     toJSON() {
         return {
             type: "full",
-            position: this.position,
             bounds: this.bounds.size,
             ids: this.ids,
             light: this.light,
@@ -109,4 +109,15 @@ export class FullVoxelTemplate {
             ...(this.mask ? { mask: this.mask } : {}),
         };
     }
+    fromJSON(data) {
+        this.bounds = new BoundingBox();
+        this.bounds.setSize(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;
+    }
 }

package/Templates/Functions/ExtrudeSelection.d.ts

@@ -0,0 +1,5 @@
+import { IVoxelSelection } from "../Selection/VoxelSelection";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+import { Vector3Like } from "@amodx/math";
+export declare function ExtrudeSelection(cursor: DataCursorInterface, selection: IVoxelSelection, normal: Vector3Like): FullVoxelTemplate;

package/Templates/Functions/ExtrudeSelection.js

@@ -0,0 +1,44 @@
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+export function ExtrudeSelection(cursor, selection, normal) {
+    const size = selection.bounds.size;
+    const template = new FullVoxelTemplate(FullVoxelTemplate.CreateNew([size.x, size.y, size.z]));
+    for (let x = selection.origin.x; x < selection.origin.x + size.x; x++) {
+        for (let y = selection.origin.y; y < selection.origin.y + size.y; y++) {
+            for (let z = selection.origin.z; z < selection.origin.z + size.z; z++) {
+                if (selection.isSelected(x, y, z)) {
+                    let nx = x;
+                    let ny = y;
+                    let nz = z;
+                    const index = template.getIndex(x - selection.origin.x, y - selection.origin.y, z - selection.origin.z);
+                    while (true) {
+                        nx -= normal.x;
+                        ny -= normal.y;
+                        nz -= normal.z;
+                        if (!selection.isSelected(nx, ny, nz)) {
+                            const voxel = cursor.getVoxel(nx, ny, nz);
+                            if (!voxel || voxel.isAir())
+                                break;
+                            template.ids[index] = voxel.ids[voxel._index];
+                            template.level[index] = voxel.level[voxel._index];
+                            template.secondary[index] = voxel.secondary[voxel._index];
+                            break;
+                        }
+                        if (x < selection.origin.x || x >= selection.origin.x + size.x)
+                            continue;
+                        if (y < selection.origin.y || y >= selection.origin.y + size.y)
+                            continue;
+                        if (z < selection.origin.z || z >= selection.origin.z + size.z)
+                            continue;
+                        const nIndex = template.getIndex(nx - selection.origin.x, ny - selection.origin.y, nz - selection.origin.z);
+                        if (!template.isAir(nIndex)) {
+                            template.ids[index] = template.ids[nIndex];
+                            template.level[index] = template.level[nIndex];
+                            template.secondary[index] = template.secondary[nIndex];
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return template;
+}

package/Templates/Functions/FillSelection.d.ts

@@ -0,0 +1,4 @@
+import { IVoxelSelection } from "../Selection/VoxelSelection";
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+export declare function FillSelection(voxel: PaintVoxelData, selection: IVoxelSelection): FullVoxelTemplate;

package/Templates/Functions/FillSelection.js

@@ -0,0 +1,20 @@
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+export function FillSelection(voxel, selection) {
+    const size = selection.bounds.size;
+    const template = new FullVoxelTemplate(FullVoxelTemplate.CreateNew([size.x, size.y, size.z]));
+    const raw = PaintVoxelData.ToRaw(voxel);
+    for (let x = selection.origin.x; x < selection.origin.x + size.x; x++) {
+        for (let y = selection.origin.y; y < selection.origin.y + size.y; y++) {
+            for (let z = selection.origin.z; z < selection.origin.z + size.z; z++) {
+                if (selection.isSelected(x, y, z)) {
+                    const index = template.getIndex(x - selection.origin.x, y - selection.origin.y, z - selection.origin.z);
+                    template.ids[index] = raw[0];
+                    template.level[index] = raw[2];
+                    template.secondary[index] = raw[3];
+                }
+            }
+        }
+    }
+    return template;
+}

package/Templates/Functions/FlipTemplate.d.ts

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