@divinevoxel/vlox 0.0.74 → 0.0.76

package/Templates/Shapes/BasicVoxelShapeTemplate.d.ts

@@ -0,0 +1,36 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { PaintVoxelData, RawVoxelData } from "../../Voxels";
+import { IVoxelShapeTemplate, IVoxelShapeTemplateData, VoxelShapeTemplateFillModes, IVoxelShapeTemplateEvents } from "./VoxelShapeTemplate.types";
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export declare abstract class BasicVoxelShapeTemplate<Type extends string, Data extends IVoxelShapeTemplateData<any>, Events extends IVoxelShapeTemplateEvents = IVoxelShapeTemplateEvents> extends TypedEventTarget<Events> implements IVoxelShapeTemplate<Type, Data, Events> {
+    static CreateBaseData<Type extends string>(type: Type, data: Partial<IVoxelShapeTemplateData<Type>>): IVoxelShapeTemplateData<Type>;
+    position: Vector3Like;
+    index: Flat3DIndex;
+    bounds: BoundingBox;
+    type: string;
+    fillMode: VoxelShapeTemplateFillModes;
+    fillVoxel: PaintVoxelData;
+    faceVoxel: PaintVoxelData;
+    edgeVoxel: PaintVoxelData;
+    pointVoxel: PaintVoxelData;
+    _fillVoxel: RawVoxelData;
+    _faceVoxel: RawVoxelData;
+    _edgeVoxel: RawVoxelData;
+    _pointVoxel: RawVoxelData;
+    constructor(data: Data);
+    setVoxels(fill: PaintVoxelData, face?: PaintVoxelData, edge?: PaintVoxelData, point?: PaintVoxelData): void;
+    getIndex(x: number, y: number, z: number): number;
+    setPosition(x: number, y: number, z: number): void;
+    abstract isIncluded(index: number): boolean;
+    abstract clone(): BasicVoxelShapeTemplate<Type, Data, Events>;
+    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;
+    protected _updateBounds(): void;
+    abstract toJSON(): Data;
+    protected getBaseJSON(): IVoxelShapeTemplateData<any>;
+}

package/Templates/Shapes/BasicVoxelShapeTemplate.js

@@ -0,0 +1,126 @@
+import { Flat3DIndex, Vector3Like } 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) {
+        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,
+        };
+    }
+    position = Vector3Like.Create();
+    index = Flat3DIndex.GetXZYOrder();
+    bounds;
+    type = "";
+    fillMode;
+    fillVoxel;
+    faceVoxel;
+    edgeVoxel;
+    pointVoxel;
+    _fillVoxel;
+    _faceVoxel;
+    _edgeVoxel;
+    _pointVoxel;
+    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);
+    }
+    setVoxels(fill, face, edge, point) {
+        this.fillVoxel = fill;
+        this.faceVoxel = face || fill;
+        this.edgeVoxel = edge || fill;
+        this.pointVoxel = point || fill;
+        this._fillVoxel = PaintVoxelData.ToRaw(this.fillVoxel);
+        this._faceVoxel = PaintVoxelData.ToRaw(this.faceVoxel);
+        this._edgeVoxel = PaintVoxelData.ToRaw(this.edgeVoxel);
+        this._pointVoxel = PaintVoxelData.ToRaw(this.pointVoxel);
+    }
+    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;
+    }
+    isAir(index) {
+        if (!this.isIncluded(index))
+            return true;
+        return this.getId(index) === 0;
+    }
+    getId(index) {
+        if (!this.isIncluded(index))
+            return 0;
+        const id = this._fillVoxel[0];
+        if (this.fillMode == "full")
+            return id;
+        return id;
+    }
+    getLight(index) {
+        if (!this.isIncluded(index))
+            return 0;
+        const light = this._fillVoxel[1];
+        if (this.fillMode == "full")
+            return light;
+        return light;
+    }
+    getLevel(index) {
+        if (!this.isIncluded(index))
+            return 0;
+        const level = this._fillVoxel[2];
+        if (this.fillMode == "full")
+            return level;
+        return level;
+    }
+    getSecondary(index) {
+        if (!this.isIncluded(index))
+            return 0;
+        const secondary = this._fillVoxel[3];
+        if (this.fillMode == "full")
+            return secondary;
+        return secondary;
+    }
+    getRaw(index, rawRef = [0, 0, 0, 0]) {
+        if (!this.isIncluded(index)) {
+            rawRef[0] = 0;
+            rawRef[1] = 0;
+            rawRef[2] = 0;
+            rawRef[3] = 0;
+            return rawRef;
+        }
+        rawRef[0] = this.getId(index);
+        rawRef[1] = this.getLight(index);
+        rawRef[2] = this.getLevel(index);
+        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);
+    }
+    getBaseJSON() {
+        return {
+            type: this.type,
+            position: this.position,
+            bounds: this.bounds.size,
+            fillMode: this.fillMode,
+            fillVoxel: this.fillVoxel,
+            faceVoxel: this.faceVoxel,
+            edgeVoxel: this.edgeVoxel,
+            pointVoxel: this.pointVoxel,
+        };
+    }
+}

package/Templates/Shapes/BoxVoxelTemplate.d.ts

@@ -0,0 +1,23 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface BoxVoxelTemplateData extends IVoxelShapeTemplateData<"box-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class BoxVoxelTemplate extends BasicVoxelShapeTemplate<"box-shape", BoxVoxelTemplateData> {
+    static CreateNew(data: Partial<BoxVoxelTemplateData>): BoxVoxelTemplateData;
+    private _width;
+    get width(): number;
+    set width(width: number);
+    private _height;
+    get height(): number;
+    set height(height: number);
+    private _depth;
+    get depth(): number;
+    set depth(depth: number);
+    constructor(data: BoxVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    clone(): BoxVoxelTemplate;
+    toJSON(): BoxVoxelTemplateData;
+}

package/Templates/Shapes/BoxVoxelTemplate.js

@@ -0,0 +1,83 @@
+import { PaintVoxelData } from "../../Voxels";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class BoxVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("box-shape", {
+                bounds: { x: data.width || 1, y: data.height || 1, z: data.depth || 1 },
+                fillVoxel: data.fillVoxel || PaintVoxelData.Create(),
+                pointVoxel: data.pointVoxel || PaintVoxelData.Create(),
+                faceVoxel: data.faceVoxel || PaintVoxelData.Create(),
+                edgeVoxel: data.edgeVoxel || PaintVoxelData.Create(),
+                fillMode: data.fillMode || "full",
+            }),
+            width: data.width || 1,
+            height: data.height || 1,
+            depth: data.depth || 1,
+        };
+    }
+    _width = 0;
+    get width() {
+        return this._width;
+    }
+    set width(width) {
+        const oldWidth = this._width;
+        this._width = width;
+        if (oldWidth != width) {
+            this.bounds.size.x = width;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _height = 0;
+    get height() {
+        return this._height;
+    }
+    set height(height) {
+        const oldWidth = this._height;
+        this._height = height;
+        if (oldWidth != height) {
+            this.bounds.size.y = height;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _depth = 0;
+    get depth() {
+        return this._depth;
+    }
+    set depth(depth) {
+        const oldWidth = this._depth;
+        this._depth = depth;
+        if (oldWidth != depth) {
+            this.bounds.size.z = depth;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    constructor(data) {
+        super(data);
+        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,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

package/Templates/Shapes/ConeVoxelTemplate.d.ts

@@ -0,0 +1,23 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface ConeVoxelTemplateData extends IVoxelShapeTemplateData<"cone-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class ConeVoxelTemplate extends BasicVoxelShapeTemplate<"cone-shape", ConeVoxelTemplateData> {
+    static CreateNew(data: Partial<ConeVoxelTemplateData>): ConeVoxelTemplateData;
+    private _width;
+    get width(): number;
+    set width(width: number);
+    private _height;
+    get height(): number;
+    set height(height: number);
+    private _depth;
+    get depth(): number;
+    set depth(depth: number);
+    constructor(data: ConeVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    clone(): ConeVoxelTemplate;
+    toJSON(): ConeVoxelTemplateData;
+}

package/Templates/Shapes/ConeVoxelTemplate.js

@@ -0,0 +1,73 @@
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class ConeVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("cone-shape", {
+                bounds: { x: data.width || 1, y: data.height || 1, z: data.depth || 1 },
+            }),
+            width: data.width || 1,
+            height: data.height || 1,
+            depth: data.depth || 1,
+        };
+    }
+    _width = 0;
+    get width() {
+        return this._width;
+    }
+    set width(width) {
+        const oldWidth = this._width;
+        this._width = width;
+        if (oldWidth != width) {
+            this.bounds.size.x = width;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _height = 0;
+    get height() {
+        return this._height;
+    }
+    set height(height) {
+        const oldWidth = this._height;
+        this._height = height;
+        if (oldWidth != height) {
+            this.bounds.size.y = height;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _depth = 0;
+    get depth() {
+        return this._depth;
+    }
+    set depth(depth) {
+        const oldWidth = this._depth;
+        this._depth = depth;
+        if (oldWidth != depth) {
+            this.bounds.size.z = depth;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    constructor(data) {
+        super(data);
+        this._width = data.width;
+        this._height = data.height;
+        this._depth = data.depth;
+    }
+    isIncluded(index) {
+        return true;
+    }
+    clone() {
+        const newTemplate = new ConeVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

package/Templates/Shapes/CylinderVoxelTemplate.d.ts

@@ -0,0 +1,23 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface CylinderVoxelTemplateData extends IVoxelShapeTemplateData<"cylinder-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class CylinderVoxelTemplate extends BasicVoxelShapeTemplate<"cylinder-shape", CylinderVoxelTemplateData> {
+    static CreateNew(data: Partial<CylinderVoxelTemplateData>): CylinderVoxelTemplateData;
+    private _width;
+    get width(): number;
+    set width(width: number);
+    private _height;
+    get height(): number;
+    set height(height: number);
+    private _depth;
+    get depth(): number;
+    set depth(depth: number);
+    constructor(data: CylinderVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    clone(): CylinderVoxelTemplate;
+    toJSON(): CylinderVoxelTemplateData;
+}

package/Templates/Shapes/CylinderVoxelTemplate.js

@@ -0,0 +1,73 @@
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class CylinderVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("cylinder-shape", {
+                bounds: { x: data.width || 1, y: data.height || 1, z: data.depth || 1 },
+            }),
+            width: data.width || 1,
+            height: data.height || 1,
+            depth: data.depth || 1,
+        };
+    }
+    _width = 0;
+    get width() {
+        return this._width;
+    }
+    set width(width) {
+        const oldWidth = this._width;
+        this._width = width;
+        if (oldWidth != width) {
+            this.bounds.size.x = width;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _height = 0;
+    get height() {
+        return this._height;
+    }
+    set height(height) {
+        const oldWidth = this._height;
+        this._height = height;
+        if (oldWidth != height) {
+            this.bounds.size.y = height;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _depth = 0;
+    get depth() {
+        return this._depth;
+    }
+    set depth(depth) {
+        const oldWidth = this._depth;
+        this._depth = depth;
+        if (oldWidth != depth) {
+            this.bounds.size.z = depth;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    constructor(data) {
+        super(data);
+        this._width = data.width;
+        this._height = data.height;
+        this._depth = data.depth;
+    }
+    isIncluded(index) {
+        return true;
+    }
+    clone() {
+        const newTemplate = new CylinderVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

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

@@ -0,0 +1,23 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface OctahedronVoxelTemplateData extends IVoxelShapeTemplateData<"octahedron-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class OctahedronVoxelTemplate extends BasicVoxelShapeTemplate<"octahedron-shape", OctahedronVoxelTemplateData> {
+    static CreateNew(data: Partial<OctahedronVoxelTemplateData>): OctahedronVoxelTemplateData;
+    private _width;
+    get width(): number;
+    set width(width: number);
+    private _height;
+    get height(): number;
+    set height(height: number);
+    private _depth;
+    get depth(): number;
+    set depth(depth: number);
+    constructor(data: OctahedronVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    clone(): OctahedronVoxelTemplate;
+    toJSON(): OctahedronVoxelTemplateData;
+}

package/Templates/Shapes/OctahedronVoxelTemplate.js

@@ -0,0 +1,73 @@
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class OctahedronVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("octahedron-shape", {
+                bounds: { x: data.width || 1, y: data.height || 1, z: data.depth || 1 },
+            }),
+            width: data.width || 1,
+            height: data.height || 1,
+            depth: data.depth || 1,
+        };
+    }
+    _width = 0;
+    get width() {
+        return this._width;
+    }
+    set width(width) {
+        const oldWidth = this._width;
+        this._width = width;
+        if (oldWidth != width) {
+            this.bounds.size.x = width;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _height = 0;
+    get height() {
+        return this._height;
+    }
+    set height(height) {
+        const oldWidth = this._height;
+        this._height = height;
+        if (oldWidth != height) {
+            this.bounds.size.y = height;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _depth = 0;
+    get depth() {
+        return this._depth;
+    }
+    set depth(depth) {
+        const oldWidth = this._depth;
+        this._depth = depth;
+        if (oldWidth != depth) {
+            this.bounds.size.z = depth;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    constructor(data) {
+        super(data);
+        this._width = data.width;
+        this._height = data.height;
+        this._depth = data.depth;
+    }
+    isIncluded(index) {
+        return true;
+    }
+    clone() {
+        const newTemplate = new OctahedronVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}