@divinevoxel/vlox 0.0.74 → 0.0.75

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

package/Templates/Functions/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./CreateTemplate";
+export * from "../Archive/Functions/CreateArchivedTemplate";
 export * from "./RotateTemplate";
 export * from "./FlipTemplate";

package/Templates/Functions/index.js

@@ -1,3 +1,3 @@
-export * from "./CreateTemplate";
+export * from "../Archive/Functions/CreateArchivedTemplate";
 export * from "./RotateTemplate";
 export * from "./FlipTemplate";

package/Templates/Path/VoxelPath.d.ts

@@ -0,0 +1,34 @@
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+import type { VoxelPathData, VoxelPathSegmentData } from "./VoxelPath.types";
+import type { Vec3Array } from "@amodx/math";
+export interface VoxelPathSegmentsEvents {
+    updated: {};
+}
+export declare class VoxelPathSegment extends TypedEventTarget<VoxelPathSegmentsEvents> implements VoxelPathSegmentData {
+    path: VoxelPath;
+    index: number;
+    static CreateNew(data: Partial<VoxelPathSegmentData>): VoxelPathSegmentData;
+    start: Vec3Array;
+    end: Vec3Array;
+    voxel: PaintVoxelData;
+    constructor(path: VoxelPath, index: number, data: VoxelPathSegmentData);
+    setPoints([sx, sy, sz]: Vec3Array, [ex, ey, ez]: Vec3Array): void;
+    getPoint(point: 0 | 1): Vec3Array;
+    setPoint(point: 0 | 1, vec: Vec3Array): void;
+    toJSON(): VoxelPathSegmentData;
+}
+export interface VoxelPathEvents {
+    segmentAdded: VoxelPathSegment;
+    segmentRemoved: VoxelPathSegment;
+}
+export declare class VoxelPath extends TypedEventTarget<VoxelPathEvents> {
+    data: VoxelPathData;
+    static CreateNew(data: Partial<VoxelPathData>): VoxelPathData;
+    segments: VoxelPathSegment[];
+    constructor(data: VoxelPathData);
+    addSegment(data: VoxelPathSegmentData): boolean;
+    removeSegment(segment: VoxelPathSegment): boolean;
+    removePoint(segmentIndex: number, pointIndex: 0 | 1): false | undefined;
+    toJSON(): VoxelPathData;
+}

package/Templates/Path/VoxelPath.js

@@ -0,0 +1,127 @@
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+export class VoxelPathSegment extends TypedEventTarget {
+    path;
+    index;
+    static CreateNew(data) {
+        return {
+            start: data.start ? data.start : [0, 0, 0],
+            end: data.end ? data.end : [0, 0, 0],
+            voxel: data.voxel ? data.voxel : PaintVoxelData.Create(),
+        };
+    }
+    start;
+    end;
+    voxel;
+    constructor(path, index, data) {
+        super();
+        this.path = path;
+        this.index = index;
+        this.start = data.start;
+        this.end = data.end;
+        this.voxel = data.voxel;
+    }
+    setPoints([sx, sy, sz], [ex, ey, ez]) {
+        let updated = false;
+        if (this.start[0] != sx || this.start[1] != sy || this.start[2] != sz) {
+            updated = true;
+        }
+        this.start[0] = sx;
+        this.start[1] = sy;
+        this.start[2] = sz;
+        if (this.end[0] != ex || this.end[1] != ey || this.end[2] != ez) {
+            updated = true;
+        }
+        this.end[0] = ex;
+        this.end[1] = ey;
+        this.end[2] = ez;
+        if (updated) {
+            this.dispatch("updated", {});
+        }
+    }
+    getPoint(point) {
+        if (point == 0)
+            return this.start;
+        if (point == 1)
+            return this.end;
+        throw new Error(`Point must be 0 or 1 get ${point}`);
+    }
+    setPoint(point, vec) {
+        if (point == 0) {
+            return this.setPoints(vec, this.end);
+        }
+        if (point == 1) {
+            return this.setPoints(this.start, vec);
+        }
+        throw new Error(`Point must be 0 or 1 get ${point}`);
+    }
+    toJSON() {
+        return {
+            start: [...this.start],
+            end: [...this.end],
+            voxel: { ...this.voxel },
+        };
+    }
+}
+export class VoxelPath extends TypedEventTarget {
+    data;
+    static CreateNew(data) {
+        return {
+            segments: data.segments ? data.segments : [],
+        };
+    }
+    segments = [];
+    constructor(data) {
+        super();
+        this.data = data;
+        for (let i = 0; i < data.segments.length; i++) {
+            this.segments.push(new VoxelPathSegment(this, i, data.segments[i]));
+        }
+    }
+    addSegment(data) {
+        const segment = new VoxelPathSegment(this, this.segments.length, data);
+        this.segments.push(segment);
+        this.dispatch("segmentAdded", segment);
+        return true;
+    }
+    removeSegment(segment) {
+        for (let i = this.segments.length - 1; i > -1; i--) {
+            this.segments[i].index--;
+            if (this.segments[i] == segment) {
+                this.segments.splice(i, 1);
+                break;
+            }
+        }
+        this.dispatch("segmentRemoved", segment);
+        return false;
+    }
+    removePoint(segmentIndex, pointIndex) {
+        if (!this.segments.length)
+            return false;
+        if (!this.segments[segmentIndex])
+            return false;
+        if (segmentIndex > 0) {
+            const segment = this.segments[segmentIndex];
+            const previousSegment = this.segments.at(segmentIndex - 1);
+            if (pointIndex == 0) {
+                previousSegment.setPoints(previousSegment.start, segment.end);
+            }
+            if (pointIndex == 1) {
+                previousSegment.setPoints(previousSegment.start, segment.start);
+            }
+            this.removeSegment(segment);
+        }
+        else {
+            this.removeSegment(this.segments[0]);
+        }
+    }
+    toJSON() {
+        const segments = [];
+        for (let i = 0; i < this.segments.length; i++) {
+            segments.push(this.segments[i].toJSON());
+        }
+        return {
+            segments,
+        };
+    }
+}

package/Templates/Path/VoxelPath.types.d.ts

@@ -0,0 +1,10 @@
+import { Vec3Array } from "@amodx/math";
+import { PaintVoxelData } from "../../Voxels";
+export type VoxelPathSegmentData = {
+    start: Vec3Array;
+    end: Vec3Array;
+    voxel: PaintVoxelData;
+};
+export type VoxelPathData = {
+    segments: VoxelPathSegmentData[];
+};

package/Templates/Path/VoxelPath.types.js

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

package/Templates/Selection/VoxelBFSSelection.d.ts

@@ -0,0 +1,20 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { IVoxelSelection } from "./VoxelSelecton";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+export interface VoxelBFSSelectionData {
+    origin: Vector3Like;
+    size: Vector3Like;
+    bitIndex: Uint8Array;
+}
+export declare class VoxelBFSSelection implements IVoxelSelection, VoxelBFSSelectionData {
+    origin: Vector3Like;
+    size: Vector3Like;
+    bitIndex: Uint8Array;
+    index: Flat3DIndex;
+    isSelected(x: number, y: number, z: number): boolean;
+    reConstruct(cursor: DataCursorInterface, position: Vector3Like, maxSize?: number): false | undefined;
+    toTemplate(cursor: DataCursorInterface): FullVoxelTemplate;
+    toJSON(): VoxelBFSSelectionData;
+    fromJSON(data: VoxelBFSSelectionData): void;
+}

package/Templates/Selection/VoxelBFSSelection.js

@@ -0,0 +1,130 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { CardinalNeighbors3D } from "../../Math/CardinalNeighbors";
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays";
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+export class VoxelBFSSelection {
+    origin = Vector3Like.Create();
+    size = Vector3Like.Create();
+    bitIndex;
+    index = Flat3DIndex.GetXZYOrder();
+    isSelected(x, y, z) {
+        if (x < this.origin.x || x >= this.origin.x + this.size.x)
+            return false;
+        if (y < this.origin.y || y >= this.origin.y + this.size.y)
+            return false;
+        if (z < this.origin.z || z >= this.origin.z + this.size.z)
+            return false;
+        return (getBitArrayIndex(this.bitIndex, this.index.getIndexXYZ(x - this.origin.x, y - this.origin.y, z - this.origin.z)) === 1);
+    }
+    reConstruct(cursor, position, maxSize = 1000) {
+        const min = Vector3Like.Create(Infinity, Infinity, Infinity);
+        const max = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+        const voxelId = cursor.getVoxel(position.x, position.y, position.z)?.getVoxelId() || 0;
+        if (!voxelId)
+            return false;
+        const queue = [position.x, position.y, position.z];
+        let size = 0;
+        const visited = new Set();
+        while (queue.length) {
+            if (size > maxSize)
+                break;
+            const x = queue.shift();
+            const y = queue.shift();
+            const z = queue.shift();
+            const key = `${x}-${y}-${z}`;
+            if (visited.has(key))
+                continue;
+            visited.add(key);
+            if (x < min.x)
+                min.x = x;
+            if (y < min.y)
+                min.y = y;
+            if (z < min.z)
+                min.z = z;
+            if (x > max.x)
+                max.x = x;
+            if (y > max.y)
+                max.y = y;
+            if (z > max.z)
+                max.z = z;
+            for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+                const n = CardinalNeighbors3D[i];
+                let nx = x + n[0];
+                let ny = y + n[1];
+                let nz = z + n[2];
+                const voxel = cursor.getVoxel(nx, ny, nz);
+                if (!voxel || voxel.getVoxelId() != voxelId)
+                    continue;
+                queue.push(nx, ny, nz);
+            }
+            size++;
+        }
+        if (min.x == Infinity || min.y == Infinity || min.z == Infinity)
+            return false;
+        if (max.x == -Infinity || max.y == -Infinity || max.z == -Infinity)
+            return false;
+        const sizeX = max.x - min.x + 1;
+        const sizeY = max.y - min.y + 1;
+        const sizeZ = max.z - min.z + 1;
+        this.index.setBounds(sizeX, sizeY, sizeZ);
+        this.bitIndex = new Uint8Array(Math.ceil((sizeX * sizeY * sizeZ) / 8));
+        for (let x = min.x; x < min.x + sizeX; x++) {
+            for (let y = min.y; y < min.y + sizeY; y++) {
+                for (let z = min.z; z < min.z + sizeZ; z++) {
+                    const key = `${x}-${y}-${z}`;
+                    if (!visited.has(key))
+                        continue;
+                    setBitArrayIndex(this.bitIndex, this.index.getIndexXYZ(x - min.x, y - min.y, z - min.z), 1);
+                }
+            }
+        }
+        this.size.x = sizeX;
+        this.size.y = sizeY;
+        this.size.z = sizeZ;
+        this.origin.x = min.x;
+        this.origin.y = min.y;
+        this.origin.z = min.z;
+    }
+    toTemplate(cursor) {
+        const templateData = FullVoxelTemplate.CreateNew([
+            this.size.x,
+            this.size.y,
+            this.size.z,
+        ]);
+        templateData.mask = this.bitIndex.slice();
+        const template = new FullVoxelTemplate(templateData);
+        for (let x = this.origin.x; x < this.origin.x + this.size.x; x++) {
+            for (let y = this.origin.y; y < this.origin.y + this.size.y; y++) {
+                for (let z = this.origin.z; z < this.origin.z + this.size.z; z++) {
+                    if (!this.isSelected(x, y, z))
+                        continue;
+                    const voxel = cursor.getVoxel(x, y, z);
+                    if (!voxel || voxel.isAir())
+                        continue;
+                    const index = template.getIndex(x - this.origin.x, y - this.origin.y, z - this.origin.z);
+                    template.ids[index] = voxel.ids[voxel._index];
+                    template.level[index] = voxel.level[voxel._index];
+                    template.secondary[index] = voxel.secondary[voxel._index];
+                }
+            }
+        }
+        return template;
+    }
+    toJSON() {
+        return {
+            origin: { ...this.origin },
+            size: { ...this.size },
+            bitIndex: this.bitIndex.slice(),
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        this.size.x = data.size.x;
+        this.size.y = data.size.y;
+        this.size.z = data.size.z;
+        this.bitIndex = data.bitIndex;
+        this.index.setBounds(this.size.x, this.size.y, this.size.z);
+    }
+}

package/Templates/Selection/VoxelBoxSelection.d.ts

@@ -0,0 +1,14 @@
+import { Vector3Like } from "@amodx/math";
+import { IVoxelSelection } from "./VoxelSelecton";
+import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+import { IVoxelshapeTemplateBaseData } from "../Shapes/VoxelShapeTemplate.types";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+export declare class VoxelBoxSelection implements IVoxelSelection {
+    origin: Vector3Like;
+    end: Vector3Like;
+    size: Vector3Like;
+    isSelected(x: number, y: number, z: number): boolean;
+    reConstruct(startPosition: Vector3Like, startNormal: Vector3Like, endPosition: Vector3Like, endNormal: Vector3Like, offset?: number): void;
+    toTemplate(data?: Partial<IVoxelshapeTemplateBaseData>): BoxVoxelTemplate;
+    toExtrudedTemplate(cursor: DataCursorInterface, normal: Vector3Like): void;
+}