@divinevoxel/vlox 0.0.73 → 0.0.75

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviors.d.ts

@@ -0,0 +1,18 @@
+import { DimensionSimulation } from "../../Dimensions/DimensionSimulation";
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
+export interface VoxelBehaviorsData {
+    type: string;
+    inherits?: string;
+    onInteract?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
+    onPaint?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
+    onErase?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
+    onTick?(simulation: DimensionSimulation, voxel: VoxelCursorInterface, x: number, y: number, z: number): void;
+}
+export declare class VoxelBehavior {
+    data: VoxelBehaviorsData;
+    constructor(data: VoxelBehaviorsData);
+    onInteract(simulation: DimensionSimulation, x: number, y: number, z: number): void;
+    onPaint(simulation: DimensionSimulation, x: number, y: number, z: number): void;
+    onErase(simulation: DimensionSimulation, x: number, y: number, z: number): void;
+    onTick(simulation: DimensionSimulation, x: number, y: number, z: number): void;
+}

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviors.js

@@ -0,0 +1,30 @@
+export class VoxelBehavior {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    onInteract(simulation, x, y, z) {
+        if (!this.data.onInteract)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        this.data.onInteract(simulation, voxel, x, y, z);
+    }
+    onPaint(simulation, x, y, z) {
+        if (!this.data.onPaint)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        this.data.onPaint(simulation, voxel, x, y, z);
+    }
+    onErase(simulation, x, y, z) {
+        if (!this.data.onErase)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        this.data.onErase(simulation, voxel, x, y, z);
+    }
+    onTick(simulation, x, y, z) {
+        if (!this.data.onTick)
+            return;
+        const voxel = simulation.getVoxelForUpdate(x, y, z);
+        this.data.onTick(simulation, voxel, x, y, z);
+    }
+}

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviorsRegister.d.ts

@@ -0,0 +1,6 @@
+import { VoxelBehavior, VoxelBehaviorsData } from "./VoxelBehaviors";
+export declare class VoxelBehaviorsRegister {
+    static behaviors: Map<string, VoxelBehavior>;
+    static register(data: VoxelBehaviorsData): void;
+    static get(type: string): VoxelBehavior;
+}

package/WorldSimulation/Voxels/Behaviors/VoxelBehaviorsRegister.js

@@ -0,0 +1,25 @@
+import { VoxelBehavior } from "./VoxelBehaviors";
+export class VoxelBehaviorsRegister {
+    static behaviors = new Map();
+    static register(data) {
+        if (!data.inherits && data.type != "dve_default")
+            data.inherits = "dve_default";
+        if (data.inherits) {
+            const otherType = this.get(data.inherits);
+            for (const key in otherType) {
+                if (key == "type" || key == "inherits")
+                    continue;
+                if (!data[key] && otherType[key]) {
+                    data[key] = otherType[key];
+                }
+            }
+        }
+        this.behaviors.set(data.type, new VoxelBehavior(data));
+    }
+    static get(type) {
+        const behavior = this.behaviors.get(type);
+        if (!behavior)
+            throw new Error(`Voxel behavior ${type} does not exist`);
+        return behavior;
+    }
+}

package/WorldSimulation/Voxels/Behaviors/VoxelUpdate.d.ts

@@ -0,0 +1,10 @@
+import { VoxelFaceNames } from "../../../Math";
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
+export interface VoxelUpdate {
+    priority: number;
+    source: VoxelCursorInterface;
+    direction: VoxelFaceNames;
+    x: number;
+    y: number;
+    z: number;
+}

package/WorldSimulation/Voxels/Behaviors/VoxelUpdate.js

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

package/WorldSimulation/Voxels/Behaviors/index.d.ts

@@ -0,0 +1,4 @@
+import "./Types/index";
+export * from "./VoxelBehaviorsRegister";
+export * from "./VoxelBehaviors";
+export * from "./VoxelUpdate";

package/WorldSimulation/Voxels/Behaviors/index.js

@@ -0,0 +1,4 @@
+import "./Types/index";
+export * from "./VoxelBehaviorsRegister";
+export * from "./VoxelBehaviors";
+export * from "./VoxelUpdate";

package/WorldSimulation/Voxels/Ticks/Types/LiquidVoxelUpdate.d.ts

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

package/WorldSimulation/Voxels/Ticks/Types/LiquidVoxelUpdate.js

@@ -0,0 +1,163 @@
+import { VoxelTickUpdateRegister } from "../VoxelTickUpdateRegister";
+import { CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
+const floodOutChecks = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+const determineLevelChecks = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+    [0, 1, 0],
+];
+function determineLiquidLevel(simulation, sourceVoxel, x, y, z) {
+    const originalLevel = sourceVoxel.getLevel();
+    if (sourceVoxel.getLevelState() == 1) {
+        const upVoxel = simulation.nDataCursor.getVoxel(x, y + 1, z);
+        if (!upVoxel || !upVoxel.isSameVoxel(sourceVoxel))
+            return Infinity;
+        return 7;
+    }
+    if (originalLevel == 7)
+        return 7;
+    let highestNeighborLevel = -1;
+    let foundHigherLevel = false;
+    for (let i = 0; i < determineLevelChecks.length; i++) {
+        const nx = x + determineLevelChecks[i][0];
+        const ny = y + determineLevelChecks[i][1];
+        const nz = z + determineLevelChecks[i][2];
+        const voxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+        if (!voxel || !voxel.isSameVoxel(sourceVoxel))
+            continue;
+        const neighborLevel = voxel.getLevel();
+        if (neighborLevel > originalLevel) {
+            foundHigherLevel = true;
+        }
+        if (neighborLevel > highestNeighborLevel) {
+            highestNeighborLevel = neighborLevel;
+        }
+    }
+    if (!foundHigherLevel) {
+        return Infinity;
+    }
+    if (highestNeighborLevel <= originalLevel) {
+        return originalLevel;
+    }
+    return Math.max(0, highestNeighborLevel - 1);
+}
+VoxelTickUpdateRegister.registerType({
+    type: "dve_liquid",
+    run(simulation, voxel, update) {
+        const { x, y, z } = update;
+        const liquidUpdateRate = 3;
+        const currentLevel = voxel.getLevel();
+        const levelState = voxel.getLevelState();
+        if (levelState == 1 && currentLevel < 7) {
+            voxel.setLevel(currentLevel + 1);
+            voxel.updateVoxel(0);
+            simulation.scheduleUpdate("dve_liquid", x, y, z, liquidUpdateRate);
+            simulation.bounds.updateDisplay(x, y, z);
+            return;
+        }
+        if (levelState == 2) {
+            voxel.setLevelState(0);
+            voxel.updateVoxel(0);
+            for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+                const nx = x + CardinalNeighbors3D[i][0];
+                const ny = y + CardinalNeighbors3D[i][1];
+                const nz = z + CardinalNeighbors3D[i][2];
+                const voxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+                if (!voxel || !voxel.substanceTags["dve_is_liquid"])
+                    continue;
+                simulation.scheduleUpdate("dve_liquid", nx, ny, nz, 0);
+            }
+            return;
+        }
+        if (currentLevel == 0) {
+            const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
+            if (downVoxel &&
+                downVoxel.isSameVoxel(voxel) &&
+                downVoxel.getLevelState() == 1) {
+                simulation.scheduleUpdate("dve_liquid", x, y - 1, z, liquidUpdateRate);
+            }
+            voxel.setAir();
+            voxel.setLevel(0);
+            voxel.updateVoxel(1);
+            simulation.bounds.updateDisplay(x, y, z);
+            for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+                const nx = x + CardinalNeighbors3D[i][0];
+                const ny = y + CardinalNeighbors3D[i][1];
+                const nz = z + CardinalNeighbors3D[i][2];
+                const voxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+                voxel?.updateVoxel(2);
+            }
+            return;
+        }
+        const finalLevel = determineLiquidLevel(simulation, voxel, x, y, z);
+        if (finalLevel == Infinity) {
+            const newLevel = currentLevel - 1;
+            voxel.setLevel(newLevel);
+            voxel.updateVoxel(0);
+            if (levelState == 1)
+                voxel.setLevelState(0);
+            simulation.scheduleUpdate("dve_liquid", x, y, z, liquidUpdateRate);
+            simulation.bounds.updateDisplay(x, y, z);
+            for (let i = 0; i < 4; i++) {
+                const nx = floodOutChecks[i][0] + x;
+                const ny = floodOutChecks[i][1] + y;
+                const nz = floodOutChecks[i][2] + z;
+                const nVoxel = simulation.nDataCursor.getVoxel(nx, ny, nz);
+                if (!nVoxel || !nVoxel.isSameVoxel(voxel))
+                    continue;
+                const nState = nVoxel.getLevelState();
+                if (nState == 2)
+                    continue;
+                if (nVoxel.getLevel() > newLevel) {
+                    simulation.scheduleUpdate("dve_liquid", nx, ny, nz, liquidUpdateRate);
+                }
+            }
+            return;
+        }
+        if (currentLevel < finalLevel) {
+            voxel.setLevel(currentLevel + 1);
+            voxel.updateVoxel(0);
+            simulation.scheduleUpdate("dve_liquid", x, y, z, liquidUpdateRate);
+            simulation.bounds.updateDisplay(x, y, z);
+        }
+        const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
+        if (!downVoxel || downVoxel.isAir() || downVoxel.isSameVoxel(voxel)) {
+            if (downVoxel) {
+                downVoxel.setId(voxel.getId());
+                downVoxel.setLevel(0);
+                downVoxel.setLevelState(1);
+                downVoxel.updateVoxel(0);
+                simulation.scheduleUpdate("dve_liquid", x, y - 1, z, liquidUpdateRate);
+            }
+            return;
+        }
+        for (let i = 0; i < 4; i++) {
+            const nx = floodOutChecks[i][0] + x;
+            const ny = floodOutChecks[i][1] + y;
+            const nz = floodOutChecks[i][2] + z;
+            const nVoxel = simulation.sDataCursor.getVoxel(nx, ny, nz);
+            if (!nVoxel || !(nVoxel.isSameVoxel(voxel) || nVoxel.isAir()))
+                continue;
+            const vLevel = nVoxel.getLevel();
+            const nState = nVoxel.getLevelState();
+            if (nState == 2)
+                continue;
+            if (vLevel + 1 < currentLevel) {
+                nVoxel.setId(voxel.getId());
+                nVoxel.setLevel(vLevel + 1);
+                nVoxel.updateVoxel(0);
+                simulation.bounds.updateDisplay(nx, ny, nz);
+                if (currentLevel - 1 > 0) {
+                    simulation.scheduleUpdate("dve_liquid", nx, ny, nz, liquidUpdateRate);
+                }
+            }
+        }
+    },
+});

package/WorldSimulation/Voxels/Ticks/Types/index.d.ts

@@ -0,0 +1 @@
+import "./LiquidVoxelUpdate";

package/WorldSimulation/Voxels/Ticks/Types/index.js

@@ -0,0 +1 @@
+import "./LiquidVoxelUpdate";

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdate.d.ts

@@ -0,0 +1,8 @@
+export declare class VoxelTickUpdate<Data extends any = null> {
+    type: string;
+    x: number;
+    y: number;
+    z: number;
+    data: Data;
+    constructor(type: string, x: number, y: number, z: number, data: Data);
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdate.js

@@ -0,0 +1,14 @@
+export class VoxelTickUpdate {
+    type;
+    x;
+    y;
+    z;
+    data;
+    constructor(type, x, y, z, data) {
+        this.type = type;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.data = data;
+    }
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdateRegister.d.ts

@@ -0,0 +1,6 @@
+import { VoxelTickUpdateType, VoxelTickUpdateTypeData } from "./VoxelTickUpdateType";
+export declare class VoxelTickUpdateRegister {
+    static _types: Map<string, VoxelTickUpdateType<null>>;
+    static getUpdateType(id: string): VoxelTickUpdateType<null>;
+    static registerType(data: VoxelTickUpdateTypeData): void;
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdateRegister.js

@@ -0,0 +1,13 @@
+import { VoxelTickUpdateType } from "./VoxelTickUpdateType";
+export class VoxelTickUpdateRegister {
+    static _types = new Map();
+    static getUpdateType(id) {
+        const type = this._types.get(id);
+        if (!type)
+            throw new Error(`Voxel update type ${id} does not exist`);
+        return type;
+    }
+    static registerType(data) {
+        this._types.set(data.type, new VoxelTickUpdateType(data));
+    }
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdateType.d.ts

@@ -0,0 +1,12 @@
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface";
+import { VoxelTickUpdate } from "./VoxelTickUpdate";
+import { DimensionSimulation } from "../../Dimensions/DimensionSimulation";
+export interface VoxelTickUpdateTypeData<Data extends any = null> {
+    type: string;
+    run(runData: DimensionSimulation, voxel: VoxelCursorInterface, update: VoxelTickUpdate<Data>): void;
+}
+export declare class VoxelTickUpdateType<Data extends any = null> {
+    data: VoxelTickUpdateTypeData<Data>;
+    constructor(data: VoxelTickUpdateTypeData<Data>);
+    run(runData: DimensionSimulation, update: VoxelTickUpdate<Data>): void;
+}

package/WorldSimulation/Voxels/Ticks/VoxelTickUpdateType.js

@@ -0,0 +1,10 @@
+export class VoxelTickUpdateType {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    run(runData, update) {
+        const voxel = runData.getVoxelForUpdate(update.x, update.y, update.z);
+        this.data.run(runData, voxel, update);
+    }
+}

package/WorldSimulation/Voxels/Ticks/index.d.ts

@@ -0,0 +1,4 @@
+import "./Types/index";
+export * from "./VoxelTickUpdate";
+export * from "./VoxelTickUpdateRegister";
+export * from "./VoxelTickUpdateType";

package/WorldSimulation/Voxels/Ticks/index.js

@@ -0,0 +1,4 @@
+import "./Types/index";
+export * from "./VoxelTickUpdate";
+export * from "./VoxelTickUpdateRegister";
+export * from "./VoxelTickUpdateType";

package/{Tasks/IWG/IWG.d.ts → WorldSimulation/WorldSimulation.d.ts}

@@ -1,29 +1,30 @@
 import { Thread, ThreadPool } from "@amodx/threads";
-import { WorldStorageInterface } from "../../World/Types/WorldStorage.interface";
-import { Generator, GeneratorData } from "./Internal/Classes/Generator";
+import { WorldStorageInterface } from "../World/Types/WorldStorage.interface";
+import { Generator, GeneratorData } from "./Dimensions/Generator";
 import { InitalLoad } from "./Procedures/InitalLoad";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
-interface IWGInitData {
+interface WorldSimulationInitData {
     parent: Thread;
-    threads: Thread | ThreadPool;
+    generators: Thread | ThreadPool;
+    meshers: Thread | ThreadPool;
     worldStorage?: WorldStorageInterface;
 }
 /**# Infinite World Generation IWG
  * Object to handle the loading and generating the world around a created generator.
  */
-export declare class IWG {
+export declare class WorldSimulation {
     private static _cullGenerators;
     static readonly _generators: Generator[];
-    static addDimension(id: string): void;
+    static addDimension(id: number): void;
     static Procedures: {
         InitalLoad: typeof InitalLoad;
         SaveAllSectors: typeof SaveAllSectors;
     };
-    static init(data: IWGInitData): void;
+    static init(data: WorldSimulationInitData): void;
     static createGenerator(data: Partial<GeneratorData>): Generator;
     static addGenerator(generator: Generator): void;
+    static getDimension(id: number): import("./Dimensions/DimensionSegment").DimensionSegment;
     static removeGenerator(generator: Generator): boolean;
-    static tick(): void;
-    static update(): void;
+    static tick(generationOnly?: boolean): void;
 }
 export {};

package/WorldSimulation/WorldSimulation.js

@@ -0,0 +1,94 @@
+import { TaskTool } from "../Tools/Tasks/TasksTool";
+import { Generator } from "./Dimensions/Generator";
+import { WorldSimulationTasks } from "./Internal/WorldSimulationTasks";
+import { WorldSimulationTools } from "./Internal/WorldSimulationTools";
+import { WorldSimulationDimensions } from "./Internal/WorldSimulationDimensions";
+import { Vector3Like } from "@amodx/math";
+import { InitalLoad } from "./Procedures/InitalLoad";
+import SaveAllSectors from "./Procedures/SaveAllSectors";
+import { runActiveSectorUpdate } from "./Internal/runActiveSectorUpdate";
+let initalized = false;
+/**# Infinite World Generation IWG
+ * Object to handle the loading and generating the world around a created generator.
+ */
+export class WorldSimulation {
+    static _cullGenerators = [];
+    static _generators = [];
+    static addDimension(id) {
+        WorldSimulationDimensions.addDimension(id);
+    }
+    static Procedures = {
+        InitalLoad,
+        SaveAllSectors,
+    };
+    static init(data) {
+        initalized = true;
+        WorldSimulationTools.parent = data.parent;
+        WorldSimulationTools.taskTool = new TaskTool(data.meshers, data.generators);
+        if (data.worldStorage)
+            WorldSimulationTools.worldStorage = data.worldStorage;
+    }
+    static createGenerator(data) {
+        if (!initalized)
+            throw new Error(`IWG must be initalized first before creating generator`);
+        return new Generator({
+            dimension: data.dimension ? data.dimension : 0,
+            position: data.position ? data.position : Vector3Like.Create(),
+            renderRadius: data.renderRadius ? data.renderRadius : 150,
+            tickRadius: data.tickRadius ? data.tickRadius : 150,
+            generationRadius: data.generationRadius ? data.generationRadius : 250,
+            maxRadius: data.maxRadius ? data.maxRadius : 300,
+            building: data.building ? data.building : undefined,
+        });
+    }
+    static addGenerator(generator) {
+        this._generators.push(generator);
+        WorldSimulationDimensions.getDimension(generator._dimension).addGenerator(generator);
+    }
+    static getDimension(id) {
+        return WorldSimulationDimensions.getDimension(id);
+    }
+    static removeGenerator(generator) {
+        WorldSimulationDimensions.getDimension(generator._dimension).removeGenerator(generator);
+        for (let i = 0; i < this._generators.length; i++) {
+            if (this._generators[i] == generator) {
+                this._generators.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    static tick(generationOnly = false) {
+        for (const [, dimension] of WorldSimulationDimensions._dimensions) {
+            dimension.incrementTick();
+            for (let i = 0; i < dimension.activeSectors._sectors.length; i++) {
+                dimension.activeSectors._sectors[i].tickUpdate();
+                dimension.activeSectors._sectors[i].generateUpdate();
+            }
+        }
+        let needActiveSectorUpdate = false;
+        for (const gen of this._generators) {
+            gen.update();
+            if (gen._dirty || gen._isNew) {
+                gen._isNew = false;
+                gen._dirty = false;
+                needActiveSectorUpdate = true;
+            }
+        }
+        if (needActiveSectorUpdate) {
+            runActiveSectorUpdate();
+        }
+        WorldSimulationTasks.worldLoadTasks.runTask();
+        WorldSimulationTasks.worldGenTasks.runTask();
+        WorldSimulationTasks.worldDecorateTasks.runTask();
+        WorldSimulationTasks.worldSunTasks.runTask();
+        WorldSimulationTasks.worldPropagationTasks.runTask();
+        if (generationOnly)
+            return;
+        WorldSimulationTasks.buildTasks.runTask(125);
+        WorldSimulationTasks.saveTasks.runTask(50);
+        WorldSimulationTasks.unloadTasks.runTask(50);
+        WorldSimulationTasks.unbuildTasks.runTask();
+    }
+}
+WorldSimulation.addDimension(0);

package/{Tasks/IWG → WorldSimulation}/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./IWG";
+export * from "./WorldSimulation";
 export * from "./Procedures/InitalLoad";

package/{Tasks/IWG → WorldSimulation}/index.js

@@ -1,2 +1,2 @@
-export * from "./IWG";
+export * from "./WorldSimulation";
 export * from "./Procedures/InitalLoad";

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.73",
+  "version": "0.0.75",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
   "devDependencies": {},
   "scripts": {
-    "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ../../LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc",
+    "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ./LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc",
     "compile": "cd src && npx tsc --watch"
   },
   "keywords": [],

package/Contexts/Constructor/DivineVoxelEngineConstructor.d.ts

@@ -1,10 +0,0 @@
-import { Threads } from "@amodx/threads/";
-import { ConstructorThreadManager } from "./ConstrcutorTheads.js";
-export type DivineVoxelEngineConstructorInitData = {};
-export declare class DivineVoxelEngineConstructor {
-    static environment: "node" | "browser";
-    static instance: DivineVoxelEngineConstructor;
-    TC: typeof Threads;
-    threads: ConstructorThreadManager;
-    constructor();
-}

package/Contexts/Constructor/DivineVoxelEngineConstructor.js

@@ -1,14 +0,0 @@
-//threadcomm
-import { Threads } from "@amodx/threads/";
-import { ConstructorThreadManager } from "./ConstrcutorTheads.js";
-export class DivineVoxelEngineConstructor {
-    static environment = "browser";
-    static instance;
-    TC = Threads;
-    threads = new ConstructorThreadManager();
-    constructor() {
-        if (DivineVoxelEngineConstructor.instance)
-            return DivineVoxelEngineConstructor.instance;
-        DivineVoxelEngineConstructor.instance = this;
-    }
-}

package/Contexts/Constructor/index.d.ts

@@ -1 +0,0 @@
-export * from "./DivineVoxelEngineConstructor.js";

package/Contexts/Constructor/index.js

@@ -1 +0,0 @@
-export * from "./DivineVoxelEngineConstructor.js";

package/Init/StartConstructor.d.ts

@@ -1,2 +0,0 @@
-import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor";
-export declare function StartContrusctor(data?: {}): Promise<DivineVoxelEngineConstructor>;

package/Init/StartConstructor.js

@@ -1,57 +0,0 @@
-import InitDataSync from "../Contexts/Base/Remote/InitDataSync";
-import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor";
-import { Threads } from "@amodx/threads";
-import { Environment } from "../Util/Environment";
-import { WorldRegister } from "../World/WorldRegister";
-import InitUpdateTasks from "../Tasks/Update/InitTasks";
-import InitPropagationTasks from "../Tasks/Propagation/InitTasks";
-import InitMesherTasks from "../Mesher/InitTask";
-import InitWorldGenerationTasks from "../Tasks/WorldGeneration/InitTasks";
-import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
-import InitMesher from "../Mesher/InitMesher";
-import InitArchiveTasks from "../World/Archive/InitTasks";
-export async function StartContrusctor(data = {}) {
-    const DVEC = new DivineVoxelEngineConstructor();
-    DivineVoxelEngineConstructor.environment = Environment.isNode()
-        ? "node"
-        : "browser";
-    let parent = "render";
-    if (DivineVoxelEngineConstructor.environment == "node") {
-        parent = "server";
-    }
-    await Threads.init("constructor", self, parent);
-    let ready = false;
-    InitDataSync({
-        onSync(data) {
-            InitMesher(data.voxels.materials.palette, data.voxels.models);
-            ready = true;
-        },
-    });
-    Threads.registerTask("clear-all", () => {
-        WorldRegister.clearAll();
-    });
-    await new Promise((resolve) => {
-        const readyCheck = () => {
-            if (ready)
-                return resolve(true);
-            setTimeout(readyCheck, 10);
-        };
-        readyCheck();
-    });
-    InitArchiveTasks({ worldThread: DVEC.threads.world });
-    InitWorldDataSync();
-    InitPropagationTasks();
-    InitMesherTasks(DVEC.threads.parent);
-    InitUpdateTasks({
-        onDone(tasks, origin) {
-            tasks.bounds.markSectionsAsDirty();
-            /*
-                  origin.runTask("build-queue", [
-                    tasks.origin[0],
-                    tasks.bounds.getSections(),
-                  ]); */
-        },
-    });
-    InitWorldGenerationTasks();
-    return DVEC;
-}

package/Mesher/Models/Common/BoundsFunctions.d.ts

@@ -1,2 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-export declare function GetBounds(vectors: Vec3Array[]): [Vec3Array, Vec3Array];

package/Mesher/Models/Common/BoxGeometryNode.d.ts

@@ -1,10 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { VoxelFaces } from "../../../Math";
-import { Quad } from "../../Geomtry/Primitives/Quad";
-import { QuadVertexWeights } from "./Calc/CalcConstants";
-import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
-export declare function GetBoxGeometryNodeData(points: [Vec3Array, Vec3Array], transform: VoxelGeometryTransform): {
-    quads: Record<VoxelFaces, Quad>;
-    vertexWeights: Record<VoxelFaces, QuadVertexWeights>;
-    quadBounds: [Vec3Array, Vec3Array][];
-};