@divinevoxel/vlox 0.0.75 → 0.0.76

package/Templates/Shapes/BoxVoxelTemplate.js

@@ -60,10 +60,18 @@ export class BoxVoxelTemplate extends BasicVoxelShapeTemplate {
         this._width = data.width;
         this._height = data.height;
         this._depth = data.depth;
+        this.bounds.size.x = data.width;
+        this.bounds.size.y = data.height;
+        this.bounds.size.z = data.depth;
+        this._updateBounds();
     }
     isIncluded(index) {
         return true;
     }
+    clone() {
+        const newTemplate = new BoxVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     toJSON() {
         return {
             width: this.width,

package/Templates/Shapes/ConeVoxelTemplate.d.ts

@@ -18,5 +18,6 @@ export declare class ConeVoxelTemplate extends BasicVoxelShapeTemplate<"cone-sha
     set depth(depth: number);
     constructor(data: ConeVoxelTemplateData);
     isIncluded(index: number): boolean;
+    clone(): ConeVoxelTemplate;
     toJSON(): ConeVoxelTemplateData;
 }

package/Templates/Shapes/ConeVoxelTemplate.js

@@ -58,6 +58,10 @@ export class ConeVoxelTemplate extends BasicVoxelShapeTemplate {
     isIncluded(index) {
         return true;
     }
+    clone() {
+        const newTemplate = new ConeVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     toJSON() {
         return {
             width: this.width,

package/Templates/Shapes/CylinderVoxelTemplate.d.ts

@@ -18,5 +18,6 @@ export declare class CylinderVoxelTemplate extends BasicVoxelShapeTemplate<"cyli
     set depth(depth: number);
     constructor(data: CylinderVoxelTemplateData);
     isIncluded(index: number): boolean;
+    clone(): CylinderVoxelTemplate;
     toJSON(): CylinderVoxelTemplateData;
 }

package/Templates/Shapes/CylinderVoxelTemplate.js

@@ -58,6 +58,10 @@ export class CylinderVoxelTemplate extends BasicVoxelShapeTemplate {
     isIncluded(index) {
         return true;
     }
+    clone() {
+        const newTemplate = new CylinderVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     toJSON() {
         return {
             width: this.width,

package/Templates/Shapes/EllipsoidVoxelTemplate.d.ts

@@ -0,0 +1,23 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface SphereVoxelTemplateData extends IVoxelShapeTemplateData<"ellipsoid-shape"> {
+    radiusX: number;
+    radiusY: number;
+    radiusZ: number;
+}
+export declare class EllipsoidVoxelTemplate extends BasicVoxelShapeTemplate<"ellipsoid-shape", SphereVoxelTemplateData> {
+    static CreateNew(data: Partial<SphereVoxelTemplateData>): SphereVoxelTemplateData;
+    private _radiusX;
+    get radiusX(): number;
+    set radiusX(radius: number);
+    private _radiusY;
+    get radiusY(): number;
+    set radiusY(radius: number);
+    private _radiusZ;
+    get radiusZ(): number;
+    set radiusZ(radius: number);
+    constructor(data: SphereVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    clone(): EllipsoidVoxelTemplate;
+    toJSON(): SphereVoxelTemplateData;
+}

package/Templates/Shapes/EllipsoidVoxelTemplate.js

@@ -0,0 +1,89 @@
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class EllipsoidVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("ellipsoid-shape", {
+                bounds: {
+                    x: (data.radiusX || 1) * 2 + 1,
+                    y: (data.radiusY || 1) * 2 + 1,
+                    z: (data.radiusZ || 1) * 2 + 1,
+                },
+            }),
+            radiusX: data.radiusX || 1,
+            radiusY: data.radiusY || 1,
+            radiusZ: data.radiusZ || 1,
+        };
+    }
+    _radiusX = 0;
+    get radiusX() {
+        return this._radiusX;
+    }
+    set radiusX(radius) {
+        const oldRadius = this._radiusX;
+        this._radiusX = radius;
+        if (oldRadius != radius) {
+            this.bounds.size.x = radius * 2 + 1;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _radiusY = 0;
+    get radiusY() {
+        return this._radiusY;
+    }
+    set radiusY(radius) {
+        const oldRadius = this._radiusY;
+        this._radiusY = radius;
+        if (oldRadius != radius) {
+            this.bounds.size.y = radius * 2 + 1;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _radiusZ = 0;
+    get radiusZ() {
+        return this._radiusZ;
+    }
+    set radiusZ(radius) {
+        const oldRadius = this._radiusZ;
+        this._radiusZ = radius;
+        if (oldRadius != radius) {
+            this.bounds.size.z = radius * 2 + 1;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    constructor(data) {
+        super(data);
+        this._radiusX = data.radiusX;
+        this._radiusY = data.radiusY;
+        this._radiusZ = data.radiusZ;
+        this.bounds.size.x = this._radiusX * 2 + 1;
+        this.bounds.size.y = this._radiusY * 2 + 1;
+        this.bounds.size.z = this._radiusZ * 2 + 1;
+        this._updateBounds();
+    }
+    isIncluded(index) {
+        const [x, y, z] = this.index.getXYZ(index);
+        const cx = Math.floor(this.bounds.size.x / 2);
+        const cy = Math.floor(this.bounds.size.y / 2);
+        const cz = Math.floor(this.bounds.size.z / 2);
+        const normX = (x - cx) / this.radiusX;
+        const normY = (y - cy) / this.radiusY;
+        const normZ = (z - cz) / this.radiusZ;
+        const distance = Math.sqrt(normX * normX + normY * normY + normZ * normZ);
+        return distance <= 1;
+    }
+    clone() {
+        const newTemplate = new EllipsoidVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            ...this.getBaseJSON(),
+            radiusX: this.radiusX,
+            radiusY: this.radiusY,
+            radiusZ: this.radiusZ,
+        };
+    }
+}

package/Templates/Shapes/OctahedronVoxelTemplate.d.ts

@@ -18,5 +18,6 @@ export declare class OctahedronVoxelTemplate extends BasicVoxelShapeTemplate<"oc
     set depth(depth: number);
     constructor(data: OctahedronVoxelTemplateData);
     isIncluded(index: number): boolean;
+    clone(): OctahedronVoxelTemplate;
     toJSON(): OctahedronVoxelTemplateData;
 }

package/Templates/Shapes/OctahedronVoxelTemplate.js

@@ -58,6 +58,10 @@ export class OctahedronVoxelTemplate extends BasicVoxelShapeTemplate {
     isIncluded(index) {
         return true;
     }
+    clone() {
+        const newTemplate = new OctahedronVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     toJSON() {
         return {
             width: this.width,

package/Templates/Shapes/PyramidVoxelTemplate.d.ts

@@ -26,5 +26,6 @@ export declare class PyramidVoxelTemplate extends BasicVoxelShapeTemplate<"pyram
     set depth(depth: number);
     constructor(data: PyramidVoxelTemplateData);
     isIncluded(index: number): boolean;
+    clone(): PyramidVoxelTemplate;
     toJSON(): PyramidVoxelTemplateData;
 }

package/Templates/Shapes/PyramidVoxelTemplate.js

@@ -80,6 +80,10 @@ export class PyramidVoxelTemplate extends BasicVoxelShapeTemplate {
         this._width = data.width;
         this._height = data.height;
         this._depth = data.depth;
+        this.bounds.size.x = this._width;
+        this.bounds.size.y = this._height;
+        this.bounds.size.z = this._depth;
+        this._updateBounds();
     }
     isIncluded(index) {
         const [x, y, z] = this.index.getXYZ(index);
@@ -127,6 +131,10 @@ export class PyramidVoxelTemplate extends BasicVoxelShapeTemplate {
                 return false;
         }
     }
+    clone() {
+        const newTemplate = new PyramidVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     toJSON() {
         return {
             width: this.width,

package/Templates/Shapes/SphereVoxelTemplate.d.ts

@@ -1,24 +1,15 @@
 import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
 import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
 export interface SphereVoxelTemplateData extends IVoxelShapeTemplateData<"sphere-shape"> {
-    radiusX: number;
-    radiusY: number;
-    radiusZ: number;
+    radius: number;
 }
 export declare class SphereVoxelTemplate extends BasicVoxelShapeTemplate<"sphere-shape", SphereVoxelTemplateData> {
     static CreateNew(data: Partial<SphereVoxelTemplateData>): SphereVoxelTemplateData;
+    private _radius;
     get radius(): number;
     set radius(radius: number);
-    private _radiusX;
-    get radiusX(): number;
-    set radiusX(radius: number);
-    private _radiusY;
-    get radiusY(): number;
-    set radiusY(radius: number);
-    private _radiusZ;
-    get radiusZ(): number;
-    set radiusZ(radius: number);
     constructor(data: SphereVoxelTemplateData);
     isIncluded(index: number): boolean;
+    clone(): SphereVoxelTemplate;
     toJSON(): SphereVoxelTemplateData;
 }

package/Templates/Shapes/SphereVoxelTemplate.js

@@ -4,24 +4,21 @@ export class SphereVoxelTemplate extends BasicVoxelShapeTemplate {
         return {
             ...BasicVoxelShapeTemplate.CreateBaseData("sphere-shape", {
                 bounds: {
-                    x: (data.radiusX || 1) * 2 + 1,
-                    y: (data.radiusY || 1) * 2 + 1,
-                    z: (data.radiusZ || 1) * 2 + 1,
+                    x: (data.radius || 1) * 2 + 1,
+                    y: (data.radius || 1) * 2 + 1,
+                    z: (data.radius || 1) * 2 + 1,
                 },
             }),
-            radiusX: data.radiusX || 1,
-            radiusY: data.radiusY || 1,
-            radiusZ: data.radiusZ || 1,
+            radius: data.radius || 1,
         };
     }
+    _radius = 0;
     get radius() {
-        return this._radiusX;
+        return this._radius;
     }
     set radius(radius) {
-        const oldRadius = this._radiusX;
-        this._radiusX = radius;
-        this._radiusY = radius;
-        this._radiusY = radius;
+        const oldRadius = this._radius;
+        this._radius = radius;
         this.bounds.size.x = radius * 2 + 1;
         this.bounds.size.y = radius * 2 + 1;
         this.bounds.size.z = radius * 2 + 1;
@@ -30,68 +27,33 @@ export class SphereVoxelTemplate extends BasicVoxelShapeTemplate {
             this.dispatch("updated", null);
         }
     }
-    _radiusX = 0;
-    get radiusX() {
-        return this._radiusX;
-    }
-    set radiusX(radius) {
-        const oldRadius = this._radiusX;
-        this._radiusX = radius;
-        if (oldRadius != radius) {
-            this.bounds.size.x = radius * 2 + 1;
-            this._updateBounds();
-            this.dispatch("updated", null);
-        }
-    }
-    _radiusY = 0;
-    get radiusY() {
-        return this._radiusY;
-    }
-    set radiusY(radius) {
-        const oldRadius = this._radiusY;
-        this._radiusY = radius;
-        if (oldRadius != radius) {
-            this.bounds.size.y = radius * 2 + 1;
-            this._updateBounds();
-            this.dispatch("updated", null);
-        }
-    }
-    _radiusZ = 0;
-    get radiusZ() {
-        return this._radiusZ;
-    }
-    set radiusZ(radius) {
-        const oldRadius = this._radiusZ;
-        this._radiusZ = radius;
-        if (oldRadius != radius) {
-            this.bounds.size.z = radius * 2 + 1;
-            this._updateBounds();
-            this.dispatch("updated", null);
-        }
-    }
     constructor(data) {
         super(data);
-        this._radiusX = data.radiusX;
-        this._radiusY = data.radiusY;
-        this._radiusZ = data.radiusZ;
+        this._radius = data.radius;
+        this.bounds.size.x = this._radius * 2 + 1;
+        this.bounds.size.y = this._radius * 2 + 1;
+        this.bounds.size.z = this._radius * 2 + 1;
+        this._updateBounds();
     }
     isIncluded(index) {
         const [x, y, z] = this.index.getXYZ(index);
         const cx = Math.floor(this.bounds.size.x / 2);
         const cy = Math.floor(this.bounds.size.y / 2);
         const cz = Math.floor(this.bounds.size.z / 2);
-        const normX = (x - cx) / this.radiusX;
-        const normY = (y - cy) / this.radiusY;
-        const normZ = (z - cz) / this.radiusZ;
+        const normX = (x - cx) / this.radius;
+        const normY = (y - cy) / this.radius;
+        const normZ = (z - cz) / this.radius;
         const distance = Math.sqrt(normX * normX + normY * normY + normZ * normZ);
         return distance <= 1;
     }
+    clone() {
+        const newTemplate = new SphereVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     toJSON() {
         return {
             ...this.getBaseJSON(),
-            radiusX: this.radiusX,
-            radiusY: this.radiusY,
-            radiusZ: this.radiusZ,
+            radius: this.radius,
         };
     }
 }

package/Templates/Shapes/TorusVoxelTemplate.d.ts

@@ -18,5 +18,6 @@ export declare class TorusVoxelTemplate extends BasicVoxelShapeTemplate<"torus-s
     set depth(depth: number);
     constructor(data: TorusVoxelTemplateData);
     isIncluded(index: number): boolean;
+    clone(): TorusVoxelTemplate;
     toJSON(): TorusVoxelTemplateData;
 }

package/Templates/Shapes/TorusVoxelTemplate.js

@@ -58,6 +58,10 @@ export class TorusVoxelTemplate extends BasicVoxelShapeTemplate {
     isIncluded(index) {
         return true;
     }
+    clone() {
+        const newTemplate = new TorusVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     toJSON() {
         return {
             width: this.width,

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

@@ -6,6 +6,8 @@ export interface IVoxelShapeTemplateEvents {
 }
 export type VoxelShapeTemplateFillModes = "full" | "outline" | "shell";
 export type VoxelShapeTemplateShapeDirections = "+x" | "-x" | "+y" | "-y" | "+z" | "-z";
+export declare const VoxelShapeTemplateFillModesArray: VoxelShapeTemplateFillModes[];
+export declare const VoxelShapeTemplateShapeDirectionsArray: VoxelShapeTemplateShapeDirections[];
 export interface IVoxelShapeTemplate<Type extends string, Data extends IVoxelShapeTemplateData<Type>, Events extends IVoxelShapeTemplateEvents = IVoxelShapeTemplateEvents> extends IVoxelTemplate<Type, Data>, TypedEventTarget<Events> {
     fillMode: VoxelShapeTemplateFillModes;
     fillVoxel: PaintVoxelData;

package/Templates/Shapes/VoxelShapeTemplate.types.js

@@ -1 +1,6 @@
-export {};
+export const VoxelShapeTemplateFillModesArray = [
+    "full",
+    "outline",
+    "shell",
+];
+export const VoxelShapeTemplateShapeDirectionsArray = ["+x", "-x", "+y", "-y", "+z", "-z"];

package/Templates/VoxelTemplates.types.d.ts

@@ -13,6 +13,7 @@ export interface IVoxelTemplate<Type extends string = "", Data extends IVoxelTem
     getLevel(index: number): number;
     getLight(index: number): number;
     getSecondary(index: number): number;
+    clone(): IVoxelTemplate;
     getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
     toJSON(): 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/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/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/Interaction/Functions/PickVoxelWorld.js

@@ -1,6 +1,5 @@
 import { Vector3Like } from "@amodx/math";
 import PickVoxel from "./PickVoxel";
-import { Axes } from "@amodx/math/Vectors/Axes";
 import { WorldSpaces } from "../../../World/WorldSpaces";
 import { WorldRegister } from "../../../World/WorldRegister";
 import { SectorCursor } from "../../../World/Cursor/SectorCursor";
@@ -12,19 +11,7 @@ import { SectorCursor } from "../../../World/Cursor/SectorCursor";
 export default async function PickVoxelWorld(cursor, rayStart, rayDirection, rayLength) {
     let t = 0;
     const d = 8;
-    const rayPosition = Vector3Like.Create(...rayStart);
-    const rd = Vector3Like.Create(...rayDirection);
-    const rayRight = Vector3Like.Cross(rd, Axes.UpReadOnly());
-    const rayUp = Vector3Like.Cross(rayRight, rd);
-    const cubeSize = 16.0;
-    const halfSize = cubeSize / 2.0;
-    const rayDirectionScaled = Vector3Like.MultiplyScalar(rd, halfSize);
-    const rayRightScaled = Vector3Like.MultiplyScalar(rayRight, halfSize);
-    const rayUpScaled = Vector3Like.MultiplyScalar(rayUp, halfSize);
-    const finalRayCubeDirection = Vector3Like.Subtract(Vector3Like.Subtract(rayDirectionScaled, rayRightScaled), rayUpScaled);
-    const finalMin = Vector3Like.Create();
-    const finalMax = Vector3Like.Create();
-    const { x: sectorSizeX, y: sectorSizeY, z: sectorSizeZ, } = WorldSpaces.sector.bounds;
+    const rayPosition = Vector3Like.Create();
     const visited = new Set();
     const sectorCursor = new SectorCursor();
     while (t < rayLength) {
@@ -32,35 +19,20 @@ export default async function PickVoxelWorld(cursor, rayStart, rayDirection, ray
         rayPosition.y = rayStart[1] + t * rayDirection[1];
         rayPosition.z = rayStart[2] + t * rayDirection[2];
         t += d;
-        const min = WorldSpaces.sector.getPosition(...Vector3Like.ToArray(Vector3Like.Subtract(rayPosition, finalRayCubeDirection)));
-        const max = WorldSpaces.sector.getPosition(...Vector3Like.ToArray(Vector3Like.Add(rayPosition, finalRayCubeDirection)));
-        max.x < min.x ? (finalMin.x = max.x) : (finalMin.x = min.x);
-        max.y < min.y ? (finalMin.y = max.y) : (finalMin.y = min.y);
-        max.z < min.z ? (finalMin.z = max.z) : (finalMin.z = min.z);
-        min.x > max.x ? (finalMax.x = min.x) : (finalMax.x = max.x);
-        min.y > max.y ? (finalMax.y = min.y) : (finalMax.y = max.y);
-        min.z > max.z ? (finalMax.z = min.z) : (finalMax.z = max.z);
-        const { x: sx, y: sy, z: sz } = finalMin;
-        const { x: ex, y: ey, z: ez } = finalMax;
-        for (let x = sx - sectorSizeX; x < ex + sectorSizeX; x += sectorSizeX) {
-            for (let z = sz - sectorSizeZ; z < ez + sectorSizeZ; z += sectorSizeZ) {
-                for (let y = sy - sectorSizeY; y < ey + sectorSizeY; y += sectorSizeY) {
-                    if (!WorldSpaces.world.inBounds(x, y, z))
-                        continue;
-                    const sector = WorldRegister.sectors.get(cursor.dimension, x, y, z);
-                    if (!sector)
-                        continue;
-                    if (visited.has(sector))
-                        continue;
-                    visited.add(sector);
-                    await sector.waitTillCheckedIn();
-                    sectorCursor.loadSector(cursor.dimension, x, y, z);
-                    const result = PickVoxel(sectorCursor, rayStart, rayDirection, rayLength);
-                    if (result !== null)
-                        return result;
-                }
-            }
-        }
+        const { x, y, z } = WorldSpaces.sector.transformPosition(rayPosition);
+        if (!WorldSpaces.world.inBounds(x, y, z))
+            continue;
+        const sector = WorldRegister.sectors.get(cursor.dimension, x, y, z);
+        if (!sector)
+            continue;
+        if (visited.has(sector))
+            continue;
+        visited.add(sector);
+        await sector.waitTillCheckedIn();
+        sectorCursor.loadSector(cursor.dimension, x, y, z);
+        const result = PickVoxel(sectorCursor, rayStart, rayDirection, rayLength);
+        if (result !== null)
+            return result;
     }
     return null;
 }

package/Voxels/Interaction/VoxelPickResult.d.ts

@@ -46,5 +46,6 @@ export declare class VoxelPickResult implements VoxelPickResultData {
     voxel: VoxelCursor;
     static FromJSON(data: VoxelPickResultData): VoxelPickResult;
     constructor(rayOrigin: Vector3Like, rayDirection: Vector3Like, rayLength: number, voxelData: RawVoxelData, position: Vector3Like, normal: Vector3Like, distance: number, normalPosition: Vector3Like, unitRayDirection: Vector3Like, unitRayVoxelFace: VoxelFaces, unitNormal: Vector3Like, unitNormalFace: VoxelFaces, delta: number);
+    clone(): VoxelPickResult;
     toJSON(): VoxelPickResultData;
 }

package/Voxels/Interaction/VoxelPickResult.js

@@ -35,6 +35,9 @@ export class VoxelPickResult {
         this.voxel.setRaw(voxelData);
         this.voxel.loadIn();
     }
+    clone() {
+        return VoxelPickResult.FromJSON(this.toJSON());
+    }
     toJSON() {
         return {
             rayOrigin: { ...this.rayOrigin },

package/Voxels/State/Schema/BinarySchemaNode.d.ts

@@ -1,7 +1,8 @@
 import { StringPalette } from "../../../Util/StringPalette";
 import { VoxelBinaryStateSchemaNode } from "../State.types";
 export declare class BinarySchemaNode {
-    name: string;
+    readonly data: VoxelBinaryStateSchemaNode;
+    get name(): string;
     valuePalette?: StringPalette;
     bitIndex: number;
     bitMask: number;

package/Voxels/State/Schema/BinarySchemaNode.js

@@ -1,11 +1,14 @@
 import { StringPalette } from "../../../Util/StringPalette";
 export class BinarySchemaNode {
-    name;
+    data;
+    get name() {
+        return this.data.name;
+    }
     valuePalette;
     bitIndex = 0;
     bitMask = 0;
     constructor(data) {
-        this.name = data.name;
+        this.data = data;
         this.bitIndex = data.bitIndex;
         this.bitMask = (1 << data.bitSize) - 1;
         if (data.values)

package/Voxels/State/Schema/Conditions/SameVoxelConditions.js

@@ -9,6 +9,8 @@ export class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
         const nx = this.schema.position.x + this.data.direction[0];
         const ny = this.schema.position.y + this.data.direction[1];
         const nz = this.schema.position.z + this.data.direction[2];
+        if (!this.schema.dataCursor.inBounds(nx, ny, nz))
+            return false;
         const nVoxel = this.schema.dataCursor.getVoxel(nx, ny, nz);
         if (!nVoxel)
             return false;

package/Voxels/Types/PaintVoxelData.d.ts

@@ -2,16 +2,26 @@ import { RawVoxelData } from "./Voxel.types";
 export declare class PaintVoxelData {
     id: string;
     name: string;
-    mod: number;
     state: number;
+    stateString: string;
+    mod: number;
+    modString: string;
     level: number;
     levelState: number;
     secondaryVoxelId: string;
     secondaryName: string;
     secondaryMod: number;
+    secondaryModString: string;
     secondaryState: number;
+    secondaryStateString: string;
     static Create(data?: Partial<PaintVoxelData>): PaintVoxelData;
+    /**Transforms numeric voxel data into a PaintVoxelData object */
     static FromRaw(data: RawVoxelData, paintData?: PaintVoxelData): PaintVoxelData;
+    /**Transforms the voxel data into numeric voxel data */
     static ToRaw(data: Partial<PaintVoxelData>, light?: number): RawVoxelData;
+    /**Restores the data to the default state of being dve_air */
+    static Clear(data: PaintVoxelData): PaintVoxelData;
+    /**Clears the target data and then copies properties from source to target. */
+    static Set(target: PaintVoxelData, source: Partial<PaintVoxelData>): PaintVoxelData;
     private constructor();
 }