@divinevoxel/vlox 0.0.75 → 0.0.77

package/Templates/Shapes/VoxelShapeTemplate.d.ts

@@ -0,0 +1,37 @@
+import { Flat3DIndex } from "@amodx/math";
+import { PaintVoxelData, RawVoxelData } from "../../Voxels";
+import { VoxelShapeTemplateData, VoxelShapeTemplateFillModes } from "./VoxelShapeTemplate.types";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { IVoxelTemplate } from "../VoxelTemplates.types";
+import { IVoxelShapeSelection, IVoxelShapeSelectionData } from "./Selections/VoxelShapeSelection";
+import type { VoxelTemplateRegister } from "../VoxelTemplateRegister";
+export declare class VoxelShapeTemplate implements IVoxelTemplate<"shape", VoxelShapeTemplateData> {
+    static Register: typeof VoxelTemplateRegister;
+    static CreateNew(data: Partial<VoxelShapeTemplateData>): VoxelShapeTemplateData;
+    index: Flat3DIndex;
+    bounds: BoundingBox;
+    fillMode: VoxelShapeTemplateFillModes;
+    fillVoxel: PaintVoxelData;
+    faceVoxel: PaintVoxelData;
+    edgeVoxel: PaintVoxelData;
+    pointVoxel: PaintVoxelData;
+    _fillVoxel: RawVoxelData;
+    _faceVoxel: RawVoxelData;
+    _edgeVoxel: RawVoxelData;
+    _pointVoxel: RawVoxelData;
+    shapeSelection: IVoxelShapeSelection<any, IVoxelShapeSelectionData<any>>;
+    constructor(data?: VoxelShapeTemplateData);
+    inBounds(x: number, y: number, z: number): boolean;
+    setVoxels(fill: PaintVoxelData, face?: PaintVoxelData, edge?: PaintVoxelData, point?: PaintVoxelData): void;
+    getIndex(x: number, y: number, z: number): number;
+    isIncluded(index: number): boolean;
+    isAir(index: number): boolean;
+    getId(index: number): number;
+    getLight(index: number): number;
+    getLevel(index: number): number;
+    getSecondary(index: number): number;
+    getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    clone(): VoxelShapeTemplate;
+    toJSON(): VoxelShapeTemplateData;
+    fromJSON(data: VoxelShapeTemplateData): void;
+}

package/Templates/Shapes/{BasicVoxelShapeTemplate.js → VoxelShapeTemplate.js}

@@ -1,25 +1,24 @@
-import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { Flat3DIndex } from "@amodx/math";
 import { PaintVoxelData } from "../../Voxels";
-import { TypedEventTarget } from "../../Util/TypedEventTarget";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
-export class BasicVoxelShapeTemplate extends TypedEventTarget {
-    static CreateBaseData(type, data) {
+import { BoxVoxelShapeSelection } from "./Selections/BoxVoxelShapeSelection";
+export class VoxelShapeTemplate {
+    static Register;
+    static CreateNew(data) {
         return {
-            type,
-            bounds: data.bounds || { x: 1, y: 1, z: 1 },
-            position: Vector3Like.Create(),
-            fillMode: "full",
-            fillVoxel: PaintVoxelData.Create(),
-            faceVoxel: PaintVoxelData.Create(),
-            edgeVoxel: PaintVoxelData.Create(),
-            pointVoxel: PaintVoxelData.Create(),
-            ...data,
+            type: "shape",
+            bounds: data.bounds ||
+                data.shapeSelection?.bounds || { x: 1, y: 1, z: 1 },
+            fillMode: data.fillMode || "full",
+            fillVoxel: data.fillVoxel || PaintVoxelData.Create(),
+            faceVoxel: data.faceVoxel || PaintVoxelData.Create(),
+            edgeVoxel: data.edgeVoxel || PaintVoxelData.Create(),
+            pointVoxel: data.pointVoxel || PaintVoxelData.Create(),
+            shapeSelection: data.shapeSelection || BoxVoxelShapeSelection.CreateNew({}),
         };
     }
-    position = Vector3Like.Create();
     index = Flat3DIndex.GetXZYOrder();
     bounds;
-    type = "";
     fillMode;
     fillVoxel;
     faceVoxel;
@@ -29,14 +28,13 @@ export class BasicVoxelShapeTemplate extends TypedEventTarget {
     _faceVoxel;
     _edgeVoxel;
     _pointVoxel;
+    shapeSelection;
     constructor(data) {
-        super();
-        this.type = data.type;
-        this.fillMode = data.fillMode;
-        this.bounds = new BoundingBox();
-        this.bounds.setMinPositionAndSize(data.position, data.bounds);
-        this.index.setBounds(data.bounds.x, data.bounds.y, data.bounds.z);
-        this.setVoxels(data.fillVoxel, data.faceVoxel, data.edgeVoxel, data.pointVoxel);
+        if (data)
+            this.fromJSON(data);
+    }
+    inBounds(x, y, z) {
+        return this.bounds.intersectsXYZ(x + 0.5, y + 0.5, z + 0.5);
     }
     setVoxels(fill, face, edge, point) {
         this.fillVoxel = fill;
@@ -51,10 +49,9 @@ export class BasicVoxelShapeTemplate extends TypedEventTarget {
     getIndex(x, y, z) {
         return this.index.getIndexXYZ(x, y, z);
     }
-    setPosition(x, y, z) {
-        this.position.x = x;
-        this.position.y = y;
-        this.position.z = z;
+    isIncluded(index) {
+        const [x, y, z] = this.index.getXYZ(index);
+        return this.shapeSelection.isSelected(x + this.shapeSelection.origin.x, y + this.shapeSelection.origin.y, z + this.shapeSelection.origin.z);
     }
     isAir(index) {
         if (!this.isIncluded(index))
@@ -107,20 +104,29 @@ export class BasicVoxelShapeTemplate extends TypedEventTarget {
         rawRef[3] = this.getSecondary(index);
         return rawRef;
     }
-    _updateBounds() {
-        this.bounds.setSize(this.bounds.size);
-        this.index.setBounds(this.bounds.size.x, this.bounds.size.y, this.bounds.size.z);
+    clone() {
+        const newTemplate = new VoxelShapeTemplate();
+        newTemplate.fromJSON(this.toJSON());
+        return newTemplate;
     }
-    getBaseJSON() {
+    toJSON() {
         return {
-            type: this.type,
-            position: this.position,
-            bounds: this.bounds.size,
+            type: "shape",
+            bounds: { ...this.bounds.size },
             fillMode: this.fillMode,
-            fillVoxel: this.fillVoxel,
-            faceVoxel: this.faceVoxel,
-            edgeVoxel: this.edgeVoxel,
-            pointVoxel: this.pointVoxel,
+            fillVoxel: { ...this.fillVoxel },
+            faceVoxel: { ...this.faceVoxel },
+            edgeVoxel: { ...this.edgeVoxel },
+            pointVoxel: { ...this.pointVoxel },
+            shapeSelection: this.shapeSelection.toJSON(),
         };
     }
+    fromJSON(data) {
+        this.fillMode = data.fillMode;
+        this.bounds = new BoundingBox();
+        this.shapeSelection = VoxelShapeTemplate.Register.createSelection(data.shapeSelection);
+        this.bounds.setSize(this.shapeSelection.bounds.size);
+        this.index.setBounds(this.bounds.size.x, this.bounds.size.y, this.bounds.size.z);
+        this.setVoxels(data.fillVoxel, data.faceVoxel, data.edgeVoxel, data.pointVoxel);
+    }
 }

package/Templates/Shapes/VoxelShapeTemplate.types.d.ts

@@ -1,25 +1,18 @@
-import { TypedEventTarget } from "../../Util/TypedEventTarget";
 import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
-import { IVoxelTemplate, IVoxelTemplateData } from "../VoxelTemplates.types";
+import { IVoxelTemplateData } from "../VoxelTemplates.types";
+import { IVoxelShapeSelectionData } from "./Selections/VoxelShapeSelection";
 export interface IVoxelShapeTemplateEvents {
     updated: null;
 }
 export type VoxelShapeTemplateFillModes = "full" | "outline" | "shell";
-export type VoxelShapeTemplateShapeDirections = "+x" | "-x" | "+y" | "-y" | "+z" | "-z";
-export interface IVoxelShapeTemplate<Type extends string, Data extends IVoxelShapeTemplateData<Type>, Events extends IVoxelShapeTemplateEvents = IVoxelShapeTemplateEvents> extends IVoxelTemplate<Type, Data>, TypedEventTarget<Events> {
-    fillMode: VoxelShapeTemplateFillModes;
-    fillVoxel: PaintVoxelData;
-    faceVoxel: PaintVoxelData;
-    edgeVoxel: PaintVoxelData;
-    pointVoxel: PaintVoxelData;
-    setVoxels(fill: PaintVoxelData, face?: PaintVoxelData, edge?: PaintVoxelData, point?: PaintVoxelData): void;
-}
+export declare const VoxelShapeTemplateFillModesArray: VoxelShapeTemplateFillModes[];
 export interface IVoxelshapeTemplateBaseData {
     fillVoxel: PaintVoxelData;
     faceVoxel: PaintVoxelData;
     edgeVoxel: PaintVoxelData;
     pointVoxel: PaintVoxelData;
     fillMode: VoxelShapeTemplateFillModes;
+    shapeSelection: IVoxelShapeSelectionData<any>;
 }
-export interface IVoxelShapeTemplateData<Type extends string> extends IVoxelTemplateData<Type>, IVoxelshapeTemplateBaseData {
+export interface VoxelShapeTemplateData extends IVoxelTemplateData<"shape">, IVoxelshapeTemplateBaseData {
 }

package/Templates/Shapes/VoxelShapeTemplate.types.js

@@ -1 +1,5 @@
-export {};
+export const VoxelShapeTemplateFillModesArray = [
+    "full",
+    "outline",
+    "shell",
+];

package/Templates/{VoxelTempateRegister.d.ts → VoxelTemplateRegister.d.ts}

@@ -1,6 +1,10 @@
+import { IVoxelSelection, IVoxelSelectionConstructor, IVoxelSelectionData } from "./Selection/VoxelSelection";
 import { IVoxelTemplate, IVoxelTemplateConstructor, IVoxelTemplateData } from "./VoxelTemplates.types";
 export declare class VoxelTemplateRegister {
     static _templates: Map<string, IVoxelTemplateConstructor<any, any>>;
+    static _selections: Map<string, IVoxelSelectionConstructor<any, any>>;
     static register(id: string, constructor: IVoxelTemplateConstructor<any>): void;
     static create<Template extends IVoxelTemplate>(data: IVoxelTemplateData<any>): Template;
+    static registerSelection(id: string, constructor: IVoxelSelectionConstructor<any>): void;
+    static createSelection<Selection extends IVoxelSelection>(data: IVoxelSelectionData<any>): Selection;
 }

package/Templates/VoxelTemplateRegister.js

@@ -0,0 +1,60 @@
+import { ArchivedVoxelTemplate } from "./Archive/ArchivedVoxelTemplate";
+import { FullVoxelTemplate } from "./Full/FullVoxelTemplate";
+import { VoxelBFSSelection } from "./Selection/VoxelBFSSelection";
+import { VoxelBoundsSelection } from "./Selection/VoxelBoundsSelection";
+import { VoxelPointSelection } from "./Selection/VoxelPointSelection";
+import { VoxelSurfaceSelection } from "./Selection/VoxelSurfaceSelection";
+import { VoxelTemplateSelection } from "./Selection/VoxelTemplateSelection";
+import { BoxVoxelShapeSelection } from "./Shapes/Selections/BoxVoxelShapeSelection";
+import { ConeVoxelShapeSelection } from "./Shapes/Selections/ConeVoxelShapeSelection";
+import { CylinderVoxelShapeSelection } from "./Shapes/Selections/CylinderVoxelShapeSelection";
+import { OctahedronVoxelShapeSelection } from "./Shapes/Selections/OctahedronVoxelShapeSelection";
+import { PyramidVoxelShapeSelection } from "./Shapes/Selections/PyramidVoxelShapeSelection";
+import { SphereVoxelShapeSelection } from "./Shapes/Selections/SphereVoxelShapeSelection";
+import { EllipsoidVoxelShapeSelection } from "./Shapes/Selections/EllipsoidVoxelShapeSelection";
+import { TorusVoxelShapeSelection } from "./Shapes/Selections/TorusVoxelShapeSelection";
+import { VoxelShapeTemplate } from "./Shapes/VoxelShapeTemplate";
+export class VoxelTemplateRegister {
+    static _templates = new Map();
+    static _selections = new Map();
+    static register(id, constructor) {
+        this._templates.set(id, constructor);
+    }
+    static create(data) {
+        const TemplateClass = this._templates.get(data.type);
+        if (!TemplateClass)
+            throw new Error(`Voxel template with type id [${data.type}] does not exist`);
+        return new TemplateClass(data);
+    }
+    static registerSelection(id, constructor) {
+        this._selections.set(id, constructor);
+    }
+    static createSelection(data) {
+        const SelectionClass = this._selections.get(data.type);
+        if (!SelectionClass)
+            throw new Error(`Voxel template with type id [${data.type}] does not exist`);
+        const selection = new SelectionClass();
+        selection.fromJSON(data);
+        return selection;
+    }
+}
+//templates
+VoxelTemplateRegister.register("full", FullVoxelTemplate);
+VoxelTemplateRegister.register("archived", ArchivedVoxelTemplate);
+VoxelTemplateRegister.register("shape", VoxelShapeTemplate);
+VoxelShapeTemplate.Register = VoxelTemplateRegister;
+//selections
+VoxelTemplateRegister.registerSelection("point", VoxelPointSelection);
+VoxelTemplateRegister.registerSelection("bounds", VoxelBoundsSelection);
+VoxelTemplateRegister.registerSelection("bfs", VoxelBFSSelection);
+VoxelTemplateRegister.registerSelection("surface", VoxelSurfaceSelection);
+VoxelTemplateRegister.registerSelection("template", VoxelTemplateSelection);
+VoxelTemplateSelection.Register = VoxelTemplateRegister;
+VoxelTemplateRegister.registerSelection("box-shape", BoxVoxelShapeSelection);
+VoxelTemplateRegister.registerSelection("sphere-shape", SphereVoxelShapeSelection);
+VoxelTemplateRegister.registerSelection("ellipsoid-shape", EllipsoidVoxelShapeSelection);
+VoxelTemplateRegister.registerSelection("pyramid-shape", PyramidVoxelShapeSelection);
+VoxelTemplateRegister.registerSelection("cylinder-shape", CylinderVoxelShapeSelection);
+VoxelTemplateRegister.registerSelection("cone-shape", ConeVoxelShapeSelection);
+VoxelTemplateRegister.registerSelection("octahedron-shape", OctahedronVoxelShapeSelection);
+VoxelTemplateRegister.registerSelection("torus-shape", TorusVoxelShapeSelection);

package/Templates/VoxelTemplates.types.d.ts

@@ -2,23 +2,23 @@ import { Flat3DIndex, Vector3Like } from "@amodx/math";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 import { RawVoxelData } from "../Voxels/Types/Voxel.types";
 export interface IVoxelTemplate<Type extends string = "", Data extends IVoxelTemplateData<Type> = any> {
-    position: Vector3Like;
     bounds: BoundingBox;
     index: Flat3DIndex;
-    setPosition(x: number, y: number, z: number): void;
     getIndex(x: number, y: number, z: number): number;
     isAir(index: number): boolean;
     isIncluded(index: number): boolean;
+    inBounds(x: number, y: number, z: number): boolean;
     getId(index: number): number;
     getLevel(index: number): number;
     getLight(index: number): number;
     getSecondary(index: number): number;
+    clone(): IVoxelTemplate;
     getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
     toJSON(): Data;
+    fromJSON(data: Data): void;
 }
 export interface IVoxelTemplateData<Type extends string> {
     type: Type;
-    position: Vector3Like;
     bounds: Vector3Like;
 }
 export interface IVoxelTemplateConstructor<Type extends string, Data extends IVoxelTemplateData<Type> = any> {

package/Textures/Classes/CompiledTexture.d.ts

@@ -6,6 +6,7 @@ export declare class CompiledTexture {
     id: string;
     static GetAtlasIndex: (x: number, y: number, boundsX: number) => number;
     static GetAtlasPosition: (index: number, boundsX: number, position?: Vec2Array) => Vec2Array;
+    originalImages: HTMLImageElement[];
     images: HTMLImageElement[];
     /**Maps texture ids to their atlas sizes  */
     atlasSizeMap: Record<string, [width: number, height: number]>;
@@ -18,4 +19,5 @@ export declare class CompiledTexture {
     constructor(id: string);
     getTextureIndex(id: TextureId): number;
     getTexturePath(id: TextureId): string;
+    getTextureData(id: TextureId): Promise<Uint8ClampedArray>;
 }

package/Textures/Classes/CompiledTexture.js

@@ -7,6 +7,7 @@ export class CompiledTexture {
         position[0] = Math.floor(index % boundsX);
         return position;
     };
+    originalImages = [];
     images = [];
     /**Maps texture ids to their atlas sizes  */
     atlasSizeMap = {};
@@ -21,6 +22,9 @@ export class CompiledTexture {
         this.animatedTexture = new TextureAnimationTexture(this);
     }
     getTextureIndex(id) {
+        if (typeof id == "number") {
+            return id;
+        }
         let finalId = "";
         let frameIndex = 0;
         if (!Array.isArray(id)) {
@@ -42,7 +46,7 @@ export class CompiledTexture {
         }
         const index = this.textureMap[finalId];
         if (index === undefined) {
-            console.warn(`Texture with id [passed in: ${id.toString()}] [final: ${finalId}] does not exist on compiled texture [${this.id}]`);
+            console.warn(`Texture with id [passed in: ${id.toString()}] [final: ${finalId}] does not exist on compiled texture [${this.id}]`, this.textureMap);
             return 0;
         }
         return index + frameIndex;
@@ -50,4 +54,18 @@ export class CompiledTexture {
     getTexturePath(id) {
         return this.images[this.getTextureIndex(id)].src;
     }
+    async getTextureData(id) {
+        const path = this.originalImages[this.getTextureIndex(id)].src;
+        const res = await fetch(path);
+        if (!res.ok)
+            throw new Error(`Failed to fetch texture: ${path}`);
+        const blob = await res.blob();
+        const bitmap = await createImageBitmap(blob);
+        const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+        const ctx = canvas.getContext("2d");
+        if (!ctx)
+            throw new Error("OffscreenCanvas context unavailable");
+        ctx.drawImage(bitmap, 0, 0);
+        return ctx.getImageData(0, 0, bitmap.width, bitmap.height).data;
+    }
 }

package/Textures/Classes/TextureAnimationTexture.d.ts

@@ -5,6 +5,6 @@ export declare class TextureAnimationTexture {
     _size: number;
     shaderTexture: any;
     constructor(_texture: CompiledTexture);
-    build(): Uint16Array;
+    build(): Uint16Array<ArrayBufferLike>;
     tick(delta: number): boolean;
 }

package/Textures/Functions/BuildTextureData.js

@@ -114,6 +114,17 @@ async function loadImageForShader(imgSrcData) {
         };
     });
 }
+async function loadImageForOriginal(imgSrcData) {
+    return new Promise((resolve, reject) => {
+        const image = typeof imgSrcData === "string" ? new Image() : imgSrcData;
+        image.onerror = reject;
+        if (typeof imgSrcData === "string")
+            image.src = imgSrcData;
+        image.onload = () => {
+            resolve(image);
+        };
+    });
+}
 function getImagePath(data, parentId = null) {
     if (data.base64)
         return data.base64;
@@ -168,11 +179,13 @@ async function process(compiled, data, textureIndex, parent, cache = false) {
     }
     if (!data.atlas) {
         compiled.images[textureIndex] = await loadImageForShader(imagePath);
+        compiled.originalImages[textureIndex] = await loadImageForOriginal(imagePath);
         return textureIndex + 1;
     }
     const tiles = await sliceImageIntoTiles(imagePath, ...data.atlas.tiles);
     for (let i = 0; i < tiles.length; i++) {
         compiled.images[textureIndex + i] = await loadImageForShader(tiles[i]);
+        compiled.originalImages[textureIndex + i] = await loadImageForOriginal(tiles[i]);
     }
     compiled.atlasSizeMap[textureId] = data.atlas.tiles;
     if (data.animated) {

package/Textures/TextureManager.d.ts

@@ -5,6 +5,7 @@ import type { TextureData } from "./Texture.types";
 export declare class TextureManager {
     static _textureTypes: Map<string, TextureData[]>;
     static _compiledTextures: Map<string, CompiledTexture>;
+    static addTextureType(typeId: string): TextureData[];
     static registerTexture(textureData: TextureData[]): void;
     static getTexture(id: string): CompiledTexture;
     static compiledTextures(props?: Omit<BuildTextureDataProps, "textures" | "type">, progress?: WorkItemProgress): Promise<void>;

package/Textures/TextureManager.js

@@ -7,14 +7,18 @@ const missingTexture = {
 export class TextureManager {
     static _textureTypes = new Map();
     static _compiledTextures = new Map();
+    static addTextureType(typeId) {
+        let type = this._textureTypes.get(typeId);
+        if (!type) {
+            type = [missingTexture];
+            this._textureTypes.set(typeId, type);
+        }
+        return type;
+    }
     static registerTexture(textureData) {
         for (const texture of textureData) {
             const typeId = texture.type || "dve_voxel";
-            let type = this._textureTypes.get(typeId);
-            if (!type) {
-                type = [missingTexture];
-                this._textureTypes.set(typeId, type);
-            }
+            let type = this.addTextureType(typeId);
             type.push(texture);
         }
     }
@@ -37,3 +41,5 @@ export class TextureManager {
         }
     }
 }
+TextureManager.addTextureType("dve_item");
+TextureManager.addTextureType("dve_voxel");

package/Tools/Brush/Brush.d.ts

@@ -4,6 +4,7 @@ import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types.js";
 import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData.js";
 import { VoxelPathData } from "../../Templates/Path/VoxelPath.types.js";
+import { IVoxelSelection } from "../../Templates/Selection/VoxelSelection.js";
 export declare class BrushTool {
     data: PaintVoxelData;
     dimension: number;
@@ -34,6 +35,7 @@ export declare class BrushTool {
     paintPath(data: VoxelPathData): void;
     erase(): this;
     eraseTemplate(voxelTemplate: IVoxelTemplate): void;
+    eraseSelection(selection: IVoxelSelection): void;
     erasePath(data: VoxelPathData): void;
     start(dimension: number, x: number, y: number, z: number): this;
     stop(): this;

package/Tools/Brush/Brush.js

@@ -5,6 +5,7 @@ import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister.j
 import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData.js";
 const air = [0, 0, 0, 0];
 const temp = [0, 0, 0, 0];
+PaintVoxelData.Set;
 export class BrushTool {
     data = PaintVoxelData.Create();
     dimension = 0;
@@ -199,6 +200,24 @@ export class BrushTool {
             }
         }
     }
+    eraseSelection(selection) {
+        const { x: ox, y: oy, z: oz } = selection.origin;
+        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 (!this.dataCursor.inBounds(tx, ty, tz))
+                        continue;
+                    if (!selection.isSelected(tx, ty, tz))
+                        continue;
+                    this.setXYZ(x, y, z).erase();
+                }
+            }
+        }
+    }
     erasePath(data) {
         throw new Error("Erase path not implemented.");
     }

package/Tools/Tasks/TasksTool.d.ts

@@ -1,5 +1,5 @@
 import { Thread, ThreadPool } from "@amodx/threads/";
-import { PaintVoxelTemplateTask, PaintVoxelTask, EraseVoxelTask, EraseVoxelTemplateTask, PaintVoxelPathTask, EraseVoxelPathTask } from "../../Tasks/Tasks.types";
+import { PaintVoxelTemplateTask, PaintVoxelTask, EraseVoxelTask, EraseVoxelTemplateTask, PaintVoxelPathTask, EraseVoxelPathTask, EraseVoxelSelectionTask } from "../../Tasks/Tasks.types";
 import { LocationData } from "../../Math";
 import { SectionSnapShotTransferData } from "../../World/SnapShot/SectionSnapShot";
 export type TaskRunModes = "async" | "sync";
@@ -39,6 +39,7 @@ declare class VoxelTasks {
     paintPath: TaskToolTask<PaintVoxelPathTask>;
     erase: TaskToolTask<EraseVoxelTask>;
     eraseTemplate: TaskToolTask<EraseVoxelTemplateTask>;
+    eraseSelection: TaskToolTask<EraseVoxelSelectionTask>;
     erasePath: TaskToolTask<EraseVoxelPathTask>;
     constructor(tool: TaskTool);
 }

package/Tools/Tasks/TasksTool.js

@@ -95,6 +95,7 @@ class VoxelTasks {
     paintPath;
     erase;
     eraseTemplate;
+    eraseSelection;
     erasePath;
     constructor(tool) {
         this.tool = tool;
@@ -103,6 +104,7 @@ class VoxelTasks {
         this.paintPath = new TaskToolTask(TasksIds.PaintVoxelPath, tool.generators);
         this.erase = new TaskToolTask(TasksIds.EraseVoxel, tool.generators);
         this.eraseTemplate = new TaskToolTask(TasksIds.EraseVoxelTemplate, tool.generators);
+        this.eraseSelection = new TaskToolTask(TasksIds.EraseVoxelSelection, tool.generators);
         this.erasePath = new TaskToolTask(TasksIds.EraseVoxelPath, tool.generators);
     }
 }

package/Util/BinaryBuffer/Functions/BinaryBufferConvert.d.ts

@@ -2,4 +2,4 @@ import { BinaryBufferFormat } from "../BinaryBuffer.types";
 export declare function DetermineSubByteArrayForBinaryBuffer(paletteSize: number): BinaryBufferFormat | null;
 export declare function GetConvertedBinaryBufferSize(source: Uint8Array | Uint16Array, format: BinaryBufferFormat): number;
 export declare function GetBinaryBufferIndexLength(source: Uint8Array | Uint16Array, format: BinaryBufferFormat): number;
-export declare function ConvertBinaryBuffer(source: Uint8Array | Uint16Array, sourceType: BinaryBufferFormat, destinationType: BinaryBufferFormat): Uint16Array | Uint8Array;
+export declare function ConvertBinaryBuffer(source: Uint8Array | Uint16Array, sourceType: BinaryBufferFormat, destinationType: BinaryBufferFormat): Uint8Array<ArrayBuffer> | Uint16Array<ArrayBuffer>;

package/Util/BinaryBuffer/Functions/BinaryBufferToTypedArray.d.ts

@@ -1,2 +1,2 @@
 import { BinaryBufferData } from "../BinaryBuffer.types";
-export default function BinaryBufferToTypedArray(buffer: BinaryBufferData): Uint16Array | Uint8Array | undefined;
+export default function BinaryBufferToTypedArray(buffer: BinaryBufferData): Uint16Array<ArrayBuffer | SharedArrayBuffer> | Uint8Array<ArrayBuffer | SharedArrayBuffer> | undefined;

package/Util/LocationData.d.ts

@@ -1,3 +1,3 @@
 import { LocationData } from "Math";
 export declare function getLocationData(view: DataView, location?: LocationData): LocationData;
-export declare function setLocationData(view: DataView, location: LocationData): DataView;
+export declare function setLocationData(view: DataView, location: LocationData): DataView<ArrayBufferLike>;

package/Voxels/Cursor/DataCursor.interface.d.ts

@@ -1,5 +1,9 @@
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 import { VoxelCursorInterface } from "./VoxelCursor.interface";
+import { Vector3Like } from "@amodx/math";
 export interface DataCursorInterface {
+    volumeBounds: BoundingBox;
+    volumePosition?: Vector3Like;
     getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
     inBounds(x: number, y: number, z: number): boolean;
     clone(): DataCursorInterface;

package/Voxels/Cursor/VoxelCursor.interface.d.ts

@@ -53,8 +53,10 @@ export declare abstract class VoxelCursorInterface {
     isRenderable(): boolean;
     isAir(): boolean;
     setAir(): this;
+    /**Get the voxels palette id. The id is the combination of the true id, state, and mod. */
     getId(): number;
     setId(id: number): this;
+    /**Get the true voxel id. Meaning the numeric id for the string id of the voxel */
     getVoxelId(): number;
     setVoxelId(id: number, state?: number, mod?: number): this;
     setStringId(id: string, state?: number, mod?: number): this;

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -173,6 +173,7 @@ export class VoxelCursorInterface {
         this.ids[this._index] = 0;
         return this;
     }
+    /**Get the voxels palette id. The id is the combination of the true id, state, and mod. */
     getId() {
         if (this.__readingSecondaryVoxel) {
             return this.secondaryId;
@@ -187,6 +188,7 @@ export class VoxelCursorInterface {
         this.ids[this._index] = id;
         return this;
     }
+    /**Get the true voxel id. Meaning the numeric id for the string id of the voxel */
     getVoxelId() {
         return this.getIndexData()[0];
     }

package/Voxels/Cursor/VoxelLightData.js

@@ -87,8 +87,8 @@ export class VoxelLightData {
         let v = 0;
         v = this.setS(s, v);
         v = this.setR(r, v);
-        v = this.setG(r, v);
-        return this.setB(r, v);
+        v = this.setG(g, v);
+        return this.setB(b, v);
     }
     /**# Set Light Values
      * ---

package/Voxels/Functions/BuildTagData.js

@@ -31,7 +31,7 @@ export function BuildTagAndPaletteData(props) {
         }
         for (const tag of VoxelTagsRegister.IncludedVoxelTags) {
             if (voxel.properties[tag] === undefined) {
-                tags[tag] = VoxelTagsRegister.VoxelTagDefaults[tag] || false;
+                tags[tag] = VoxelTagsRegister.VoxelTagDefaults[tag] ?? false;
                 continue;
             }
             if (props?.voxelsOverrides?.[tag]) {

package/Voxels/Indexes/VoxelIndex.d.ts

@@ -33,6 +33,7 @@ export declare class VoxelIndex {
     stateArray: VoxelNamedStateContainer[];
     tagIndexes: Map<string, TagIndex>;
     constructor(data: VoxelData[]);
+    private findState;
     getStateFromPaintData(data: PaintVoxelData): VoxelNamedState | false;
     getStateFromRawData(data: RawVoxelData): VoxelNamedState | false;
 }

package/Voxels/Indexes/VoxelIndex.js

@@ -104,11 +104,7 @@ export class VoxelIndex {
             }
         }
     }
-    getStateFromPaintData(data) {
-        const conatiner = this.states.get(data.id);
-        if (!conatiner)
-            return false;
-        const { mod, state } = data;
+    findState(conatiner, mod, state) {
         for (const modelState of conatiner?.stateArray) {
             if ((mod == modelState.compiled.mod || modelState.compiled.modAny) &&
                 (state == modelState.compiled.state || modelState.compiled.stateAny))
@@ -116,17 +112,19 @@ export class VoxelIndex {
         }
         return false;
     }
+    getStateFromPaintData(data) {
+        const conatiner = this.states.get(data.id);
+        if (!conatiner)
+            return false;
+        const { mod, state } = data;
+        return this.findState(conatiner, mod, state);
+    }
     getStateFromRawData(data) {
         const [id, light, secondary] = data;
-        const [, mod, state] = VoxelPalettesRegister.voxels[id];
-        const conatiner = this.states.get(VoxelPalettesRegister.voxelIds.getStringId(id));
+        const [trueId, state, mod] = VoxelPalettesRegister.voxels[id];
+        const conatiner = this.states.get(VoxelPalettesRegister.voxelIds.getStringId(trueId));
         if (!conatiner)
             return false;
-        for (const modelState of conatiner?.stateArray) {
-            if ((mod == modelState.compiled.mod || modelState.compiled.modAny) &&
-                (state == modelState.compiled.state || modelState.compiled.stateAny))
-                return modelState;
-        }
-        return false;
+        return this.findState(conatiner, mod, state);
     }
 }