@divinevoxel/vlox 0.0.74 → 0.0.76

package/Templates/Shapes/PyramidVoxelTemplate.d.ts

@@ -0,0 +1,31 @@
+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;
+    clone(): PyramidVoxelTemplate;
+    toJSON(): PyramidVoxelTemplateData;
+}

package/Templates/Shapes/PyramidVoxelTemplate.js

@@ -0,0 +1,148 @@
+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;
+        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);
+        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;
+        }
+    }
+    clone() {
+        const newTemplate = new PyramidVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
+    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,15 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface SphereVoxelTemplateData extends IVoxelShapeTemplateData<"sphere-shape"> {
+    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);
+    constructor(data: SphereVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    clone(): SphereVoxelTemplate;
+    toJSON(): SphereVoxelTemplateData;
+}

package/Templates/Shapes/SphereVoxelTemplate.js

@@ -0,0 +1,59 @@
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class SphereVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("sphere-shape", {
+                bounds: {
+                    x: (data.radius || 1) * 2 + 1,
+                    y: (data.radius || 1) * 2 + 1,
+                    z: (data.radius || 1) * 2 + 1,
+                },
+            }),
+            radius: data.radius || 1,
+        };
+    }
+    _radius = 0;
+    get radius() {
+        return this._radius;
+    }
+    set radius(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;
+        if (oldRadius != radius) {
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    constructor(data) {
+        super(data);
+        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.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(),
+            radius: this.radius,
+        };
+    }
+}

package/Templates/Shapes/TorusVoxelTemplate.d.ts

@@ -0,0 +1,23 @@
+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;
+    clone(): TorusVoxelTemplate;
+    toJSON(): TorusVoxelTemplateData;
+}

package/Templates/Shapes/TorusVoxelTemplate.js

@@ -0,0 +1,73 @@
+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;
+    }
+    clone() {
+        const newTemplate = new TorusVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

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

@@ -0,0 +1,27 @@
+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 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;
+    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,6 @@
+export const VoxelShapeTemplateFillModesArray = [
+    "full",
+    "outline",
+    "shell",
+];
+export const VoxelShapeTemplateShapeDirectionsArray = ["+x", "-x", "+y", "-y", "+z", "-z"];

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

package/Templates/VoxelTempateRegister.js

@@ -0,0 +1,30 @@
+import { ArchivedVoxelTemplate } from "./Archive/ArchivedVoxelTemplate";
+import { FullVoxelTemplate } from "./Full/FullVoxelTemplate";
+import { BoxVoxelTemplate } from "./Shapes/BoxVoxelTemplate";
+import { ConeVoxelTemplate } from "./Shapes/ConeVoxelTemplate";
+import { CylinderVoxelTemplate } from "./Shapes/CylinderVoxelTemplate";
+import { OctahedronVoxelTemplate } from "./Shapes/OctahedronVoxelTemplate";
+import { PyramidVoxelTemplate } from "./Shapes/PyramidVoxelTemplate";
+import { SphereVoxelTemplate } from "./Shapes/SphereVoxelTemplate";
+import { TorusVoxelTemplate } from "./Shapes/TorusVoxelTemplate";
+export class VoxelTemplateRegister {
+    static _templates = new Map();
+    static register(id, constructor) {
+        this._templates.set(id, constructor);
+    }
+    static create(data) {
+        const TemplateClass = this._templates.get(data.type);
+        if (!TemplateClass)
+            throw new Error(`Voxel template with type id [${data.type}] does not exist`);
+        return new TemplateClass(data);
+    }
+}
+VoxelTemplateRegister.register("full", FullVoxelTemplate);
+VoxelTemplateRegister.register("archived", ArchivedVoxelTemplate);
+VoxelTemplateRegister.register("box-shape", BoxVoxelTemplate);
+VoxelTemplateRegister.register("sphere-shape", SphereVoxelTemplate);
+VoxelTemplateRegister.register("pyramid-shape", PyramidVoxelTemplate);
+VoxelTemplateRegister.register("cylinder-shape", CylinderVoxelTemplate);
+VoxelTemplateRegister.register("cone-shape", ConeVoxelTemplate);
+VoxelTemplateRegister.register("octahedron-shape", OctahedronVoxelTemplate);
+VoxelTemplateRegister.register("torus-shape", TorusVoxelTemplate);

package/Templates/VoxelTemplates.types.d.ts

@@ -1,29 +1,27 @@
-import { Vec3Array } from "@amodx/math";
-import { VoxelDataArrays } from "../Voxels";
-export interface VoxelTemplateBuffers {
-    ids: Uint16Array | Uint8Array | number;
-    state: Uint16Array | Uint8Array | number;
-    level: Uint8Array | number;
-    mod: Uint16Array | Uint8Array | number;
-    secondary: Uint16Array | Uint8Array | number;
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { RawVoxelData } from "../Voxels/Types/Voxel.types";
+export interface IVoxelTemplate<Type extends string = "", Data extends IVoxelTemplateData<Type> = any> {
+    position: Vector3Like;
+    bounds: BoundingBox;
+    index: Flat3DIndex;
+    setPosition(x: number, y: number, z: number): void;
+    getIndex(x: number, y: number, z: number): number;
+    isAir(index: number): boolean;
+    isIncluded(index: number): boolean;
+    getId(index: number): number;
+    getLevel(index: number): number;
+    getLight(index: number): number;
+    getSecondary(index: number): number;
+    clone(): IVoxelTemplate;
+    getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    toJSON(): Data;
 }
-export interface FullVoxelTemplateData extends VoxelDataArrays {
-    size: Vec3Array;
+export interface IVoxelTemplateData<Type extends string> {
+    type: Type;
+    position: Vector3Like;
+    bounds: Vector3Like;
 }
-export interface VoxelTemplatePaletteData {
-    id: string[];
-    level: Uint8Array;
-    state: Uint16Array;
-    mod: Uint16Array;
-    secondaryId: string[];
-    secondaryState: Uint16Array;
-}
-export interface VoxelTemplateData {
-    /** Number representing the version of the templator used. */
-    templatorVersion: number;
-    /** Number representing the version of the voxel data. */
-    version: number;
-    size: Vec3Array;
-    palettes: VoxelTemplatePaletteData;
-    buffers: VoxelTemplateBuffers;
+export interface IVoxelTemplateConstructor<Type extends string, Data extends IVoxelTemplateData<Type> = any> {
+    new (data: Data): IVoxelTemplate<Type, Data>;
 }

package/Templates/index.d.ts

@@ -1 +1 @@
-export * from "./Functions/CreateTemplate";
+export * from "./Archive/Functions/CreateArchivedTemplate";

package/Templates/index.js

@@ -1 +1 @@
-export * from "./Functions/CreateTemplate";
+export * from "./Archive/Functions/CreateArchivedTemplate";

package/Textures/Classes/CompiledTexture.d.ts

@@ -7,9 +7,12 @@ export declare class CompiledTexture {
     static GetAtlasIndex: (x: number, y: number, boundsX: number) => number;
     static GetAtlasPosition: (index: number, boundsX: number, position?: Vec2Array) => Vec2Array;
     images: HTMLImageElement[];
+    /**Maps texture ids to their atlas sizes  */
     atlasSizeMap: Record<string, [width: number, height: number]>;
+    /**Maps texture ids to their index */
     textureMap: Record<string, number>;
     animations: CompiledTextureAnimation[];
+    /**To be used by the renderer to store a refernce to the actual texture used for rendering */
     shaderTexture: any;
     animatedTexture: TextureAnimationTexture;
     constructor(id: string);

package/Textures/Classes/CompiledTexture.js

@@ -8,9 +8,12 @@ export class CompiledTexture {
         return position;
     };
     images = [];
+    /**Maps texture ids to their atlas sizes  */
     atlasSizeMap = {};
+    /**Maps texture ids to their index */
     textureMap = {};
     animations = [];
+    /**To be used by the renderer to store a refernce to the actual texture used for rendering */
     shaderTexture;
     animatedTexture;
     constructor(id) {

package/Textures/Classes/CompiledTextureAnimation.d.ts

@@ -7,6 +7,6 @@ export declare class CompiledTextureAnimation {
     _current: number;
     _animatedTextureIndex: number;
     constructor(textureIndex: number);
-    tick(delta: number): boolean;
+    tick(delta: number): boolean | undefined;
     getIndex(): number;
 }

package/Textures/Classes/CompiledTextureAnimation.js

@@ -4,13 +4,19 @@ export class CompiledTextureAnimation {
     _times = [];
     _currentTime = 0;
     _frameIndex = 0;
-    _current = Infinity;
+    _current = -1;
     _animatedTextureIndex = -1;
     constructor(textureIndex) {
         this.textureIndex = textureIndex;
     }
     tick(delta) {
-        if (this._current == Infinity)
+        if (!this._frames.length || !this._times.length)
+            return;
+        if (Number.isNaN(this._current)) {
+            console.error("ERROR NAN", this._current, this._frameIndex, delta);
+            return;
+        }
+        if (this._current == -1)
             this._current = this._times[0];
         this._current -= delta;
         if (this._current <= 0) {

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/Textures/Functions/BuildTextureData.d.ts

@@ -1,5 +1,6 @@
 import { CompiledTexture } from "../Classes/CompiledTexture";
 import { TextureData } from "../../Textures/Texture.types";
+import { WorkItemProgress } from "../../Util/WorkItemProgress";
 export type BuildTextureDataProps = {
     type: string;
     baseURL?: string;
@@ -7,4 +8,4 @@ export type BuildTextureDataProps = {
     textures: TextureData[];
     finalSize?: [width: number, height: number];
 };
-export declare function BuildTextureData({ type, baseURL: currentBaseURL, textures, finalSize: currentFinalSize, createCache, }: BuildTextureDataProps): Promise<CompiledTexture>;
+export declare function BuildTextureData({ type, baseURL: currentBaseURL, textures, finalSize: currentFinalSize, createCache, }: BuildTextureDataProps, progress: WorkItemProgress): Promise<CompiledTexture>;