@divinevoxel/vlox 0.0.73 → 0.0.75

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

package/Templates/Selection/VoxelBoxSelection.js

@@ -0,0 +1,105 @@
+import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
+import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+const getMinMax = (...points) => {
+    if (points.length === 0) {
+        throw new Error("At least one point is required to calculate min/max.");
+    }
+    let min = [...points[0]];
+    let max = [...points[0]];
+    for (const point of points) {
+        for (let i = 0; i < 3; i++) {
+            if (point[i] < min[i]) {
+                min[i] = point[i];
+            }
+            if (point[i] > max[i]) {
+                max[i] = point[i];
+            }
+        }
+    }
+    return [min, max];
+};
+const getSize = (start, end) => {
+    return Vector3Like.Create(end.x - start.x, end.y - start.y, end.z - start.z);
+};
+export class VoxelBoxSelection {
+    origin = Vector3Like.Create();
+    end = Vector3Like.Create();
+    size = Vector3Like.Create();
+    isSelected(x, y, z) {
+        if (x < this.origin.x || x >= this.end.x)
+            return false;
+        if (y < this.origin.y || y >= this.end.y)
+            return false;
+        if (z < this.origin.z || z >= this.end.z)
+            return false;
+        return true;
+    }
+    reConstruct(startPosition, startNormal, endPosition, endNormal, offset = 0) {
+        const size = getSize(startPosition, endPosition);
+        const point1 = [
+            startPosition.x,
+            startPosition.y,
+            startPosition.z,
+        ];
+        const point2 = Vec3ArrayLike.Add(point1, [
+            size.x || 1,
+            size.y || 1,
+            size.z || 1,
+        ]);
+        const minPoint = [
+            Math.min(point1[0], point2[0]),
+            Math.min(point1[1], point2[1]),
+            Math.min(point1[2], point2[2]),
+        ];
+        const maxPoint = [
+            Math.max(point1[0], point2[0]),
+            Math.max(point1[1], point2[1]),
+            Math.max(point1[2], point2[2]),
+        ];
+        if (size.x < 0)
+            maxPoint[0] += 1;
+        if (size.y < 0)
+            maxPoint[1] += 1;
+        if (size.z < 0)
+            maxPoint[2] += 1;
+        const normalOffset = Vec3ArrayLike.Add([startPosition.x, startPosition.y, startPosition.z], Vec3ArrayLike.MultiplyScalar([startNormal.x, startNormal.y, startNormal.z], offset));
+        const [finalMin, finalMax] = getMinMax(minPoint, maxPoint, normalOffset);
+        const finalSize = [
+            Math.abs(finalMax[0] - finalMin[0]),
+            Math.abs(finalMax[1] - finalMin[1]),
+            Math.abs(finalMax[2] - finalMin[2]),
+        ];
+        if (finalSize[0] == 0 && finalSize[1] == 0 && finalSize[2] == 0) {
+            this.origin.x = startPosition.x;
+            this.origin.y = startPosition.y;
+            this.origin.z = startPosition.z;
+            this.end.x = startPosition.x + startNormal.x;
+            this.end.y = startPosition.y + startNormal.y;
+            this.end.z = startPosition.z + startNormal.z;
+            this.size.x = 1;
+            this.size.y = 1;
+            this.size.z = 1;
+        }
+        else {
+            this.origin.x = finalMin[0];
+            this.origin.y = finalMin[1];
+            this.origin.z = finalMin[2];
+            this.end.x = finalMax[0];
+            this.end.y = finalMax[1];
+            this.end.z = finalMax[2];
+            this.size.x = finalSize[0];
+            this.size.y = finalSize[1];
+            this.size.z = finalSize[2];
+        }
+    }
+    toTemplate(data) {
+        const boxTemplate = BoxVoxelTemplate.CreateNew({
+            width: this.size.x,
+            height: this.size.y,
+            depth: this.size.z,
+            ...(data ? data : {}),
+        });
+        return new BoxVoxelTemplate(boxTemplate);
+    }
+    toExtrudedTemplate(cursor, normal) { }
+}

package/Templates/Selection/VoxelSelecton.d.ts

@@ -0,0 +1,6 @@
+import { Vector3Like } from "@amodx/math";
+export interface IVoxelSelection {
+    origin: Vector3Like;
+    size: Vector3Like;
+    isSelected(x: number, y: number, z: number): boolean;
+}

package/Templates/Selection/VoxelSelecton.js

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

package/Templates/Selection/VoxelSurfaceSelection.d.ts

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