@divinevoxel/vlox 0.0.4 → 0.0.6

package/Textures/Texture.types.d.ts

@@ -1,3 +1,4 @@
+export type TextureId = [type: string, id: string, varation?: string];
 export type TextureTypes = string;
 export type TextureTypeUVMap = Record<string, Record<string, number>>;
 export type TextureAnimationData = {

package/Textures/TextureManager.d.ts

@@ -1,16 +1,15 @@
-import type { TextureData, TextureTypeUVMap } from "./Texture.types";
+import type { TextureData, TextureTypeUVMap, TextureId } from "./Texture.types";
 import { TextureArray } from "./TextureArray.js";
-import { ConstructorTextureData } from "./Constructor.types";
 export declare class TextureManager {
     static defaultTexturePath: string;
     static textureTypes: Map<string, TextureArray>;
-    static getTextureIndex(data: ConstructorTextureData): number;
+    static getTextureIndex(data: TextureId): number;
     static _ready: boolean;
     static isReady(): boolean;
-    static $INIT(): Promise<void>;
+    static init(): Promise<void>;
     static generateTextureUVMap(): TextureTypeUVMap;
     static defineDefaultTexturePath(path: string): void;
-    static getTextureData([type, id, segment]: ConstructorTextureData): TextureData | undefined;
+    static getTextureData([type, id, segment]: TextureId): TextureData | undefined;
     static getTextureType(id: string): false | TextureArray;
     static getOrAddTextureType(id: string): TextureArray;
     static addTextureType(id: string): TextureArray;

package/Textures/TextureManager.js

@@ -1,6 +1,7 @@
 import { EngineSettings } from "../Settings/EngineSettings.js";
 import { TextureBuilder } from "./TextureBuilder.js";
 import { TextureArray } from "./TextureArray.js";
+import { TextureRegister } from "./TextureRegister.js";
 export class TextureManager {
     static defaultTexturePath = "assets/textures";
     static textureTypes = new Map();
@@ -15,11 +16,12 @@ export class TextureManager {
     static isReady() {
         return this._ready;
     }
-    static async $INIT() {
+    static async init() {
         TextureBuilder.defineTextureDimensions(EngineSettings.settings.textures.textureSize, EngineSettings.settings.textures.mipMapSizes);
         for (const [key, type] of this.textureTypes) {
             await type.build();
         }
+        TextureRegister.setTextureIndex(this.generateTextureUVMap());
         this._ready = true;
     }
     static generateTextureUVMap() {

package/Textures/TextureRegister.d.ts

@@ -1,10 +1,9 @@
-import type { ConstructorTextureData } from "./Constructor.types";
-import type { TextureTypeUVMap } from "./Texture.types";
-export declare const TextureRegister: {
-    textureDataHasBeenSet: boolean;
-    data: TextureTypeUVMap;
-    getTextureUV(data: ConstructorTextureData): number;
-    setTextureIndex(data: TextureTypeUVMap): void;
-    releaseTextureData(): void;
-    isReady(): boolean;
-};
+import type { TextureTypeUVMap, TextureId } from "./Texture.types";
+export declare class TextureRegister {
+    static textureDataHasBeenSet: boolean;
+    static data: TextureTypeUVMap;
+    static getTextureUV(data: TextureId): number;
+    static setTextureIndex(data: TextureTypeUVMap): void;
+    static releaseTextureData(): void;
+    static isReady(): boolean;
+}

package/Textures/TextureRegister.js

@@ -1,7 +1,7 @@
-export const TextureRegister = {
-    textureDataHasBeenSet: false,
-    data: {},
-    getTextureUV(data) {
+export class TextureRegister {
+    static textureDataHasBeenSet = false;
+    static data;
+    static getTextureUV(data) {
         const [textureType, textureId, varation] = data;
         let id = textureId;
         if (varation) {
@@ -13,16 +13,16 @@ export const TextureRegister = {
             throw new Error(`Texture with id: ${id} does not exists.`);
         }
         return uv;
-    },
-    setTextureIndex(data) {
+    }
+    static setTextureIndex(data) {
         this.textureDataHasBeenSet = true;
         this.data = data;
-    },
-    releaseTextureData() {
+    }
+    static releaseTextureData() {
         this.data = null;
         delete this["data"];
-    },
-    isReady() {
+    }
+    static isReady() {
         return this.textureDataHasBeenSet;
-    },
-};
+    }
+}

package/Textures/index.d.ts

@@ -0,0 +1 @@
+export * from "./Texture.types";

package/Textures/index.js

@@ -0,0 +1 @@
+export * from "./Texture.types";

package/Tools/Brush/AdvancedBrushTool.d.ts

@@ -2,8 +2,9 @@ import { BrushTool } from "./Brush.js";
 import { TaskRunModes, TaskTool } from "../Tasks/TasksTool.js";
 import { LocationData } from "Math/index.js";
 export declare class AdvancedBrush extends BrushTool {
-    _location: LocationData;
     tasks: TaskTool;
+    _location: LocationData;
+    constructor(tasks: TaskTool);
     mode: TaskRunModes;
     _mapLocation(): void;
     setMode(mode: TaskRunModes): this;

package/Tools/Brush/AdvancedBrushTool.js

@@ -1,10 +1,11 @@
-//util
-//tools
 import { BrushTool } from "./Brush.js";
-import { TaskTool } from "../Tasks/TasksTool.js";
 export class AdvancedBrush extends BrushTool {
+    tasks;
     _location = ["main", 0, 0, 0];
-    tasks = new TaskTool();
+    constructor(tasks) {
+        super();
+        this.tasks = tasks;
+    }
     mode = "async";
     _mapLocation() {
         this._location[0] = this.dimension;
@@ -33,27 +34,24 @@ export class AdvancedBrush extends BrushTool {
     }
     paintAndUpdate(onDone) {
         this._mapLocation();
-        this.tasks.setFocalPoint(this._location);
-        this.tasks.voxelUpdate.paint.run(this._location, this.getRaw(), () => {
+        this.tasks.voxel.paint.run([this._location, this.getRaw()], null, () => {
             if (onDone)
                 onDone();
-        }, this.mode);
+        });
     }
     eraseAndUpdate(onDone) {
         this._mapLocation();
-        this.tasks.setFocalPoint(this._location);
-        this.tasks.voxelUpdate.erase.run(this._location, () => {
+        this.tasks.voxel.erease.run(this._location, null, () => {
             if (onDone)
                 onDone();
-        }, this.mode);
+        });
     }
     update(onDone) {
         this._mapLocation();
-        this.tasks.setFocalPoint(this._location);
-        this.tasks.voxelUpdate.update.run(this._location, this.getRaw(), () => {
+        this.tasks.voxel.update.run([this._location, this.getRaw()], null, () => {
             if (onDone)
                 onDone();
-        }, this.mode);
+        });
     }
     updateAndAwait() {
         return new Promise((resolve) => {
@@ -64,8 +62,7 @@ export class AdvancedBrush extends BrushTool {
     }
     explode(radius = 6, onDone) {
         this._mapLocation();
-        this.tasks.setFocalPoint(this._location);
-        this.tasks.explosion.run(this._location, radius, () => {
+        this.tasks.explosion.run([this._location, radius], null, () => {
             if (onDone)
                 onDone();
         });

package/Tools/Brush/Brush.d.ts

@@ -1,8 +1,7 @@
-import type { RawVoxelData } from "../../Voxels/Voxel.types.js";
-import { PaintVoxelData } from "../../Data/Types/WorldData.types.js";
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
+import type { PaintVoxelData, RawVoxelData } from "../../Voxels/Types/Voxel.types.js";
+import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 export declare class BrushTool {
     data: PaintVoxelData;
     dimension: string;
@@ -14,6 +13,7 @@ export declare class BrushTool {
     dataCursor: WorldCursor;
     substanceData: SubstanceDataTool;
     setXYZ(x: number, y: number, z: number): this;
+    newSector(): void;
     setData(data: Partial<PaintVoxelData>): this;
     getData(): PaintVoxelData;
     setRaw(data: RawVoxelData): this;

package/Tools/Brush/Brush.js

@@ -1,19 +1,20 @@
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette.js";
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
+import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette.js";
+import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
+import { WorldRegister } from "../../World/WorldRegister.js";
 const airId = "dve_air";
-const air = [0, 0, 0, 0, 0];
+const air = [0, 0, 0, 0, 0, 0];
 export class BrushTool {
     data = {
         id: airId,
-        shapeState: 0,
-        secondaryVoxelId: airId,
+        state: 0,
+        secondaryVoxelId: "",
         level: 0,
         levelState: 0,
         mod: 0,
     };
-    dimension;
+    dimension = "main";
     x = 0;
     y = 0;
     z = 0;
@@ -27,9 +28,12 @@ export class BrushTool {
         this.z = z;
         return this;
     }
+    newSector() {
+        WorldRegister.sectors.new(this.dimension, this.x, this.y, this.z);
+    }
     setData(data) {
         this.data.id = data.id ? data.id : airId;
-        this.data.shapeState = data.shapeState ? data.shapeState : 0;
+        this.data.state = data.state ? data.state : 0;
         this.data.secondaryVoxelId = data.secondaryVoxelId
             ? data.secondaryVoxelId
             : airId;
@@ -44,7 +48,7 @@ export class BrushTool {
     setRaw(data) {
         this.voxelCursor.copyRaw(data).process();
         this.data.id = this.voxelCursor.getStringId();
-        this.data.shapeState = this.voxelCursor.getShapeState();
+        this.data.state = this.voxelCursor.getState();
         this.data.levelState = this.voxelCursor.getLevelState();
         this.data.level = this.voxelCursor.getLevel();
         this.voxelCursor.setSecondary(true);
@@ -72,7 +76,7 @@ export class BrushTool {
         return this;
     }
     setShapeState(state) {
-        this.data.shapeState = state;
+        this.data.state = state;
         return this;
     }
     setLevel(level) {
@@ -89,16 +93,18 @@ export class BrushTool {
     }
     clear() {
         this.data.id = "dve_air";
-        this.data.secondaryVoxelId = "dve_air";
+        this.data.secondaryVoxelId = "";
         this.data.level = 0;
         this.data.levelState = 0;
-        this.data.shapeState = 0;
+        this.data.state = 0;
         this.data.mod = 0;
         this.x = 0;
         this.y = 0;
         this.z = 0;
     }
     _paint() {
+        if (!this.dataCursor.inBounds(this.x, this.y, this.z))
+            return false;
         const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         if (!voxel)
             return;
@@ -106,17 +112,10 @@ export class BrushTool {
         if (id < 0)
             return false;
         voxel.setId(id);
-        voxel.setShapeState(this.data.shapeState ? this.data.shapeState : 0);
-        const substance = voxel.getSubstance();
-        if (substance > -1 && !voxel.isAir()
-            ? this.substanceData.setSubstance(voxel.getSubstance()).isLiquid()
-            : false) {
-            voxel.setLevel(7);
-        }
+        voxel.setState(this.data.state ? this.data.state : 0);
+        voxel.setLevel(this.data.level);
         voxel.setMod(this.data.mod);
-        if (this.data.secondaryVoxelId &&
-            this.data.secondaryVoxelId != "dve_air" &&
-            voxel.canHaveSecondaryVoxel()) {
+        if (this.data.secondaryVoxelId) {
             const vid = VoxelPalette.ids.getNumberId(this.data.secondaryVoxelId);
             if (vid > 0) {
                 voxel.setSecondary(true);

package/Tools/Data/SubstanceDataTool.d.ts

@@ -1,10 +1,11 @@
-import { SubstanceStruct } from "../../Data/Structs/SubstanceStruct.js";
+import { SubstanceStruct } from "../../Voxels/Structs/SubstanceStruct.js";
 export declare class SubstanceDataTool {
     static tags: typeof SubstanceStruct;
     substanceTagIndex: number;
     setSubstanceFromString(substance: string): this;
     setSubstance(substance: number): this;
     getSubstanceStringId(): string;
+    isSolid(): boolean;
     isLiquid(): boolean;
     isWindAffected(): boolean;
     getParent(): string;

package/Tools/Data/SubstanceDataTool.js

@@ -1,7 +1,7 @@
-import { SubstancePalette } from "../../Data/Palettes/SubstancePalette.js";
-import { SubstanceStruct } from "../../Data/Structs/SubstanceStruct.js";
+import { SubstancePalette } from "../../Voxels/Palettes/SubstancePalette.js";
 import { MappedDataRegister } from "../../Data/Register/MappedDataRegister.js";
-import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
+import { SubstanceStructIds } from "../../Voxels/Types/VoxelSubstances.types.js";
+import { SubstanceStruct } from "../../Voxels/Structs/SubstanceStruct.js";
 export class SubstanceDataTool {
     static tags = SubstanceStruct;
     //substance = "";
@@ -25,9 +25,10 @@ export class SubstanceDataTool {
       return SubstanceStruct.instance[SubstanceStructIds.isTransparent] == 1;
     }
   
+   */
     isSolid() {
-      return SubstanceStruct.instance[SubstanceStructIds.isSolid] == 1;
-    } */
+        return SubstanceStruct.instance[SubstanceStructIds.isSolid] == 1;
+    }
     isLiquid() {
         return SubstanceStruct.instance[SubstanceStructIds.isLiquid] == 1;
     }

package/Tools/Tasks/TasksTool.d.ts

@@ -1,92 +1,47 @@
-import { BuildTasks, GenerateTasks, Priorities } from "../../Tasks/Tasks.types";
+import { Thread, ThreadPool } from "@amodx/threads/";
+import { ExplosionTasks, GenerateTasks, VoxelUpdateTasks } from "../../Tasks/Tasks.types";
 import { LocationData } from "../../Math";
-import type { RawVoxelData } from "../../Voxels/Voxel.types.js";
 export type TaskRunModes = "async" | "sync";
+declare class TaskQueue<Data extends any = any, ReturnData extends any = void> {
+    private _task;
+    private _queue;
+    constructor(_task: TaskToolTask<Data, ReturnData>);
+    add(data: Data): void;
+    clear(): void;
+    run(): Promise<unknown>;
+}
+export declare class TaskToolTask<Data extends any = any, ReturnData extends any = void> {
+    id: string | number;
+    private _count;
+    _threads: Thread[];
+    constructor(id: string | number, threads: Thread | ThreadPool);
+    run(data: Data, transfer?: any[] | null, onDone?: (returnData: ReturnData) => void | null): void;
+    runAsync(data: Data, transfer?: any[] | null): Promise<ReturnData>;
+    createQueue(): TaskQueue<Data, ReturnData>;
+}
+declare class VoxelTasks {
+    tool: TaskTool;
+    update: TaskToolTask<VoxelUpdateTasks>;
+    paint: TaskToolTask<VoxelUpdateTasks>;
+    erease: TaskToolTask<LocationData>;
+    constructor(tool: TaskTool);
+}
+declare class BuildTask {
+    tool: TaskTool;
+    section: TaskToolTask<LocationData>;
+    sector: TaskToolTask<LocationData>;
+    constructor(tool: TaskTool);
+}
 export declare class TaskTool {
-    _data: {
-        dimension: string;
-        queue: string;
-    };
-    _thread: string;
-    _priority: Priorities;
-    constructor();
-    setPriority(priority: Priorities): this;
-    setFocalPoint(location: LocationData): this;
-    voxelUpdate: {
-        update: {
-            run: (location: LocationData, raw: RawVoxelData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
-        };
-        erase: {
-            run: (location: LocationData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
-        };
-        paint: {
-            run: (location: LocationData, raw: RawVoxelData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
-        };
-    };
-    build: {
-        chunk: {
-            deferred: {
-                run: (buildTasks: BuildTasks, onDone: (data: any) => void) => void;
-            };
-            queued: {
-                add: (location: LocationData) => void;
-                run: (onDone: Function) => void;
-                runAndAwait: () => Promise<void>;
-            };
-        };
-        column: {
-            queued: {};
-            deferred: {
-                run: (location: LocationData, onDone: (data: any) => void) => void;
-            };
-        };
-    };
-    explosion: {
-        run: (location: LocationData, radius: number, onDone: (data: any) => void) => void;
-    };
-    anaylzer: {
-        update: {
-            run: (location: LocationData, onDone: (data: any) => void) => void;
-        };
-    };
-    propagation: {
-        deferred: {
-            run: (location: LocationData, onDone: (data: any) => void) => void;
-        };
-        queued: {
-            add: (location: LocationData) => void;
-            run: (onDone: Function) => void;
-            runAndAwait: () => Promise<void>;
-        };
-    };
-    generate: {
-        deferred: {
-            run(location: LocationData, data: any, onDone: (data: any) => void): void;
-        };
-        queued: {
-            add: (data: GenerateTasks) => void;
-            run: (onDone: Function) => void;
-            runAndAwait: () => Promise<void>;
-        };
-    };
-    decorate: {
-        deferred: {
-            run: (location: LocationData, data: any, onDone: (data: any) => void) => void;
-        };
-        queued: {
-            add: (data: GenerateTasks) => Promise<void>;
-            run: (onDone: Function) => void;
-            runAndAwait: () => Promise<void>;
-        };
-    };
-    worldSun: {
-        deferred: {
-            run: (location: LocationData, onDone: (data: any) => void) => void;
-        };
-        queued: {
-            add: (location: LocationData) => void;
-            run: (onDone: Function) => void;
-            runAndAwait: () => Promise<void>;
-        };
-    };
+    threads: Thread | ThreadPool;
+    voxel: VoxelTasks;
+    build: BuildTask;
+    explosion: TaskToolTask<ExplosionTasks>;
+    anaylzer: TaskToolTask<LocationData>;
+    propagation: TaskToolTask<LocationData>;
+    generate: TaskToolTask<GenerateTasks>;
+    decorate: TaskToolTask<GenerateTasks>;
+    worldSun: TaskToolTask<LocationData>;
+    constructor(threads: Thread | ThreadPool);
 }
+export {};