@divinevoxel/vlox 0.0.74 → 0.0.75

package/Templates/Shapes/ConeVoxelTemplate.js

@@ -0,0 +1,69 @@
+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;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

package/Templates/Shapes/CylinderVoxelTemplate.d.ts

@@ -0,0 +1,22 @@
+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;
+    toJSON(): CylinderVoxelTemplateData;
+}

package/Templates/Shapes/CylinderVoxelTemplate.js

@@ -0,0 +1,69 @@
+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;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

package/Templates/Shapes/OctahedronVoxelTemplate.d.ts

@@ -0,0 +1,22 @@
+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;
+    toJSON(): OctahedronVoxelTemplateData;
+}

package/Templates/Shapes/OctahedronVoxelTemplate.js

@@ -0,0 +1,69 @@
+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;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

package/Templates/Shapes/PyramidVoxelTemplate.d.ts

@@ -0,0 +1,30 @@
+import { IVoxelShapeTemplateData, VoxelShapeTemplateShapeDirections } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface PyramidVoxelTemplateData extends IVoxelShapeTemplateData<"pyramid-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+    direction: VoxelShapeTemplateShapeDirections;
+    fallOff: number;
+}
+export declare class PyramidVoxelTemplate extends BasicVoxelShapeTemplate<"pyramid-shape", PyramidVoxelTemplateData> {
+    static CreateNew(data: Partial<PyramidVoxelTemplateData>): PyramidVoxelTemplateData;
+    private _fallOff;
+    get fallOff(): number;
+    set fallOff(fallOFf: number);
+    private _direction;
+    get direction(): VoxelShapeTemplateShapeDirections;
+    set direction(direction: VoxelShapeTemplateShapeDirections);
+    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: PyramidVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    toJSON(): PyramidVoxelTemplateData;
+}

package/Templates/Shapes/PyramidVoxelTemplate.js

@@ -0,0 +1,140 @@
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class PyramidVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("pyramid-shape", {
+                bounds: { x: data.width || 1, y: data.height || 1, z: data.depth || 1 },
+            }),
+            width: data.width || 12,
+            height: data.height || 12,
+            depth: data.depth || 12,
+            direction: data.direction || "+y",
+            fallOff: data.fallOff || 1,
+        };
+    }
+    _fallOff = 0;
+    get fallOff() {
+        return this._fallOff;
+    }
+    set fallOff(fallOFf) {
+        const oldDirection = this._fallOff;
+        this._fallOff = fallOFf;
+        if (oldDirection != fallOFf) {
+            this.dispatch("updated", null);
+        }
+    }
+    _direction = "+y";
+    get direction() {
+        return this._direction;
+    }
+    set direction(direction) {
+        const oldDirection = this._direction;
+        this._direction = direction;
+        if (oldDirection != direction) {
+            this.dispatch("updated", null);
+        }
+    }
+    _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._fallOff = data.fallOff;
+        this._direction = data.direction;
+        this._width = data.width;
+        this._height = data.height;
+        this._depth = data.depth;
+    }
+    isIncluded(index) {
+        const [x, y, z] = this.index.getXYZ(index);
+        switch (this.direction) {
+            case "+y": // Pyramid pointing up
+                {
+                    const normalizedFallOff = y * this.fallOff;
+                    const minX = normalizedFallOff;
+                    const minZ = normalizedFallOff;
+                    const maxX = this.width - normalizedFallOff;
+                    const maxZ = this.depth - normalizedFallOff;
+                    if (x >= minX && z >= minZ && x < maxX && z < maxZ)
+                        return true;
+                    return false;
+                }
+                break;
+            case "-y": {
+                // Pyramid pointing down
+                const normalizedFallOff = (this.height - 1 - y) * this.fallOff;
+                const minX = normalizedFallOff;
+                const minZ = normalizedFallOff;
+                const maxX = this.width - normalizedFallOff;
+                const maxZ = this.depth - normalizedFallOff;
+                if (x >= minX && z >= minZ && x < maxX && z < maxZ)
+                    return true;
+                return false;
+            }
+            case "+x": {
+                // Pyramid pointing right
+                return true;
+            }
+            case "-x": {
+                // Pyramid pointing left
+                return true;
+            }
+            case "+z": {
+                // Pyramid pointing forward
+                return true;
+            }
+            case "-z": {
+                // Pyramid pointing backward
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            direction: this.direction,
+            fallOff: this.fallOff,
+            ...this.getBaseJSON(),
+        };
+    }
+}

package/Templates/Shapes/SphereVoxelTemplate.d.ts

@@ -0,0 +1,24 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface SphereVoxelTemplateData extends IVoxelShapeTemplateData<"sphere-shape"> {
+    radiusX: number;
+    radiusY: number;
+    radiusZ: number;
+}
+export declare class SphereVoxelTemplate extends BasicVoxelShapeTemplate<"sphere-shape", SphereVoxelTemplateData> {
+    static CreateNew(data: Partial<SphereVoxelTemplateData>): SphereVoxelTemplateData;
+    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;
+    toJSON(): SphereVoxelTemplateData;
+}

package/Templates/Shapes/SphereVoxelTemplate.js

@@ -0,0 +1,97 @@
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class SphereVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("sphere-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,
+        };
+    }
+    get radius() {
+        return this._radiusX;
+    }
+    set radius(radius) {
+        const oldRadius = this._radiusX;
+        this._radiusX = radius;
+        this._radiusY = radius;
+        this._radiusY = radius;
+        this.bounds.size.x = radius * 2 + 1;
+        this.bounds.size.y = radius * 2 + 1;
+        this.bounds.size.z = radius * 2 + 1;
+        if (oldRadius != radius) {
+            this._updateBounds();
+            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;
+    }
+    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;
+    }
+    toJSON() {
+        return {
+            ...this.getBaseJSON(),
+            radiusX: this.radiusX,
+            radiusY: this.radiusY,
+            radiusZ: this.radiusZ,
+        };
+    }
+}

package/Templates/Shapes/TorusVoxelTemplate.d.ts

@@ -0,0 +1,22 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface TorusVoxelTemplateData extends IVoxelShapeTemplateData<"torus-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class TorusVoxelTemplate extends BasicVoxelShapeTemplate<"torus-shape", TorusVoxelTemplateData> {
+    static CreateNew(data: Partial<TorusVoxelTemplateData>): TorusVoxelTemplateData;
+    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: TorusVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    toJSON(): TorusVoxelTemplateData;
+}

package/Templates/Shapes/TorusVoxelTemplate.js

@@ -0,0 +1,69 @@
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class TorusVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("torus-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;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

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

@@ -0,0 +1,25 @@
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+import { IVoxelTemplate, IVoxelTemplateData } from "../VoxelTemplates.types";
+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 interface IVoxelshapeTemplateBaseData {
+    fillVoxel: PaintVoxelData;
+    faceVoxel: PaintVoxelData;
+    edgeVoxel: PaintVoxelData;
+    pointVoxel: PaintVoxelData;
+    fillMode: VoxelShapeTemplateFillModes;
+}
+export interface IVoxelShapeTemplateData<Type extends string> extends IVoxelTemplateData<Type>, IVoxelshapeTemplateBaseData {
+}

package/Templates/Shapes/VoxelShapeTemplate.types.js

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

package/Templates/VoxelTempateRegister.d.ts

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