@divinevoxel/vlox 0.0.80 → 0.0.81

package/WorldSimulation/Tasks/SimulationTaskBase.js

@@ -1,8 +1,11 @@
 import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions.js";
 export class SimulationTaskBase {
     data;
-    constructor(data) {
+    parent;
+    _subTask = new Map();
+    constructor(data, parent) {
         this.data = data;
+        this.parent = parent;
     }
     getTotal(dimensionId) {
         const dimension = WorldSimulationDimensions.getDimension(dimensionId);
@@ -21,6 +24,9 @@ export class SimulationTaskBase {
             return;
         task.add(x, y, z);
     }
+    addSubTask(data) {
+        this._subTask.set(data.id, new SimulationTaskBase(data, this));
+    }
     runTask(max = 10) {
         for (const [key, dimension] of WorldSimulationDimensions._dimensions) {
             const task = dimension.getTask(this.data.id);
@@ -45,8 +51,13 @@ export class SimulationTaskBase {
                     addBack.push(x, y, z);
                     continue;
                 }
-                const taskId = task.addTask(x, y, z);
+                const taskId = task.addTask(x, y, z, this._subTask.size);
                 this.data.run(dimension, location, taskId, task, sector);
+                if (this._subTask.size) {
+                    for (const [, subTask] of this._subTask) {
+                        subTask.data.run(dimension, location, taskId, task, sector);
+                    }
+                }
                 if (task.waitingFor > max)
                     break;
             }

package/WorldSimulation/Tasks/TaskSegment.d.ts

@@ -7,13 +7,15 @@ export declare class TaskSegment {
     _hash: Set<unknown>;
     nodes: LocationData[];
     waitingFor: number;
-    clear(): void;
     _taskCount: number;
     _task: Map<number, LocationData>;
+    _subTask: Map<number, number>;
     constructor(dimension: DimensionSegment, generationTask: boolean, log?: boolean);
+    clearAll(): void;
     _getLocationData(dimension: number, x: number, y: number, z: number): LocationData;
     completeTask(id: number): boolean;
-    addTask(x: number, y: number, z: number): number;
+    completeSubTask(id: number): false | undefined;
+    addTask(x: number, y: number, z: number, subTaskCount: number): number;
     has(x: number, y: number, z: number): boolean;
     add(x: number, y: number, z: number): false | undefined;
     sort(x: number, y: number, z: number): LocationData[];

package/WorldSimulation/Tasks/TaskSegment.js

@@ -1,5 +1,12 @@
+import { Distance3D } from "@amodx/math";
 import { WorldSpaces } from "../../World/WorldSpaces";
 const pool = [];
+const sortPosition = [0, 0, 0];
+const sort = (a, b) => {
+    const ad = Distance3D(sortPosition[0], sortPosition[1], sortPosition[2], a[1], a[2], a[3]);
+    const bd = Distance3D(sortPosition[0], sortPosition[1], sortPosition[2], b[1], b[2], b[3]);
+    return bd - ad;
+};
 export class TaskSegment {
     dimension;
     generationTask;
@@ -7,16 +14,20 @@ export class TaskSegment {
     _hash = new Set();
     nodes = [];
     waitingFor = 0;
-    clear() { }
     _taskCount = 0;
     _task = new Map();
+    _subTask = new Map();
     constructor(dimension, generationTask, log = false) {
         this.dimension = dimension;
         this.generationTask = generationTask;
         this.log = log;
     }
+    clearAll() {
+        this.nodes = [];
+        this._task.clear();
+    }
     _getLocationData(dimension, x, y, z) {
-        const location = pool.length ? pool.shift() : [0, 0, 0, 0];
+        const location = pool.length ? pool.pop() : [0, 0, 0, 0];
         location[0] = dimension;
         location[1] = x;
         location[2] = y;
@@ -24,6 +35,9 @@ export class TaskSegment {
         return location;
     }
     completeTask(id) {
+        const subTaskCount = this._subTask.get(id);
+        if (subTaskCount !== undefined && subTaskCount > 0)
+            return false;
         const locationData = this._task.get(id);
         if (!locationData)
             return false;
@@ -33,9 +47,23 @@ export class TaskSegment {
         this.waitingFor--;
         return true;
     }
-    addTask(x, y, z) {
+    completeSubTask(id) {
+        const subTaskCount = this._subTask.get(id);
+        if (subTaskCount === undefined)
+            return false;
+        const newSubTaskCount = subTaskCount - 1;
+        if (newSubTaskCount <= 0) {
+            this._subTask.set(id, 0);
+            this.completeTask(id);
+        }
+        else {
+            this._subTask.set(id, newSubTaskCount);
+        }
+    }
+    addTask(x, y, z, subTaskCount) {
         const id = this._taskCount;
         this._task.set(id, this._getLocationData(this.dimension.id, x, y, z));
+        this._subTask.set(id, subTaskCount);
         this._taskCount++;
         this.waitingFor++;
         return id;
@@ -53,29 +81,15 @@ export class TaskSegment {
     }
     sort(x, y, z) {
         const sections = this.nodes;
-        const sx = x, sy = y, sz = z;
-        let i = sections.length, j, temp, ax, ay, az, bx, by, bz, distA, distB;
-        while (i > 1) {
-            for (j = 1; j < i; j++) {
-                (ax = sections[j - 1][1]),
-                    (ay = sections[j - 1][2]),
-                    (az = sections[j - 1][3]);
-                (bx = sections[j][1]), (by = sections[j][2]), (bz = sections[j][3]);
-                distA = (ax - sx) ** 2 + (ay - sy) ** 2 + (az - sz) ** 2;
-                distB = (bx - sx) ** 2 + (by - sy) ** 2 + (bz - sz) ** 2;
-                if (distA > distB) {
-                    temp = sections[j - 1];
-                    sections[j - 1] = sections[j];
-                    sections[j] = temp;
-                }
-            }
-            i--;
-        }
+        sortPosition[0] = x;
+        sortPosition[1] = y;
+        sortPosition[2] = z;
+        this.nodes.sort(sort);
         return sections;
     }
     *run() {
         while (this.nodes.length) {
-            const vec = this.nodes.shift();
+            const vec = this.nodes.pop();
             const key = WorldSpaces.hash.hashXYZ(vec[1], vec[2], vec[3]);
             this._hash.delete(key);
             yield vec;

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

@@ -1,6 +1,5 @@
 import { VoxelTickUpdateRegister } from "../VoxelTickUpdateRegister";
 import { CardinalNeighbors3D } from "../../../../Math/CardinalNeighbors";
-import { VoxelFaces } from "../../../../Math";
 const floodOutChecks = [
     [1, 0, 0],
     [-1, 0, 0],
@@ -127,7 +126,7 @@ VoxelTickUpdateRegister.registerType({
             simulation.bounds.updateDisplay(x, y, z);
         }
         const downVoxel = simulation.nDataCursor.getVoxel(x, y - 1, z);
-        const below = simulation.tickCursor[VoxelFaces.Down].getVoxel(x, y - 2, z);
+        const below = simulation.tickCursor[1 /* VoxelFaces.Down */].getVoxel(x, y - 2, z);
         const isSame = downVoxel && downVoxel.isSameVoxel(voxel);
         if (downVoxel && (downVoxel.isAir() || isSame)) {
             let addToTick = false;

package/WorldSimulation/WorldSimulation.d.ts

@@ -1,8 +1,9 @@
 import { Thread, ThreadPool } from "@amodx/threads";
 import { WorldStorageInterface } from "../World/Types/WorldStorage.interface";
 import { Generator, GeneratorData } from "./Dimensions/Generator";
+import { WorldSimulationTasks } from "./Internal/WorldSimulationTasks";
+import { WorldSimulationTools } from "./Internal/WorldSimulationTools";
 import { InitalLoad } from "./Procedures/InitalLoad";
-import { BuildOnly } from "./Procedures/BuildOnly";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 interface WorldSimulationInitData {
     parent: Thread;
@@ -16,11 +17,12 @@ interface WorldSimulationInitData {
 export declare class WorldSimulation {
     private static _cullGenerators;
     static readonly _generators: Generator[];
+    static Tools: typeof WorldSimulationTools;
+    static Tasks: typeof WorldSimulationTasks;
     static addDimension(id: number): void;
     static Procedures: {
         InitalLoad: typeof InitalLoad;
         SaveAllSectors: typeof SaveAllSectors;
-        BuildOnly: typeof BuildOnly;
     };
     static logTasks(): {
         loading: number[];
@@ -36,6 +38,7 @@ export declare class WorldSimulation {
     static getDimension(id: number): import("./Dimensions/DimensionSegment").DimensionSegment;
     static removeGenerator(generator: Generator): boolean;
     static doTickUpdates: boolean;
-    static tick(generationOnly?: boolean): void;
+    static clearAll(): void;
+    static tick(generationOnly?: boolean, buildOnly?: boolean): void;
 }
 export {};

package/WorldSimulation/WorldSimulation.js

@@ -1,3 +1,4 @@
+import { Thread } from "@amodx/threads";
 import { TaskTool } from "../Tools/Tasks/TasksTool";
 import { Generator } from "./Dimensions/Generator";
 import { WorldSimulationTasks } from "./Internal/WorldSimulationTasks";
@@ -5,9 +6,9 @@ import { WorldSimulationTools } from "./Internal/WorldSimulationTools";
 import { WorldSimulationDimensions } from "./Internal/WorldSimulationDimensions";
 import { Vector3Like } from "@amodx/math";
 import { InitalLoad } from "./Procedures/InitalLoad";
-import { BuildOnly } from "./Procedures/BuildOnly";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 import { runActiveSectorUpdate } from "./Internal/runActiveSectorUpdate";
+import { WorldRegister } from "../World/WorldRegister";
 let initalized = false;
 /**# Infinite World Generation IWG
  * Object to handle the loading and generating the world around a created generator.
@@ -15,13 +16,14 @@ let initalized = false;
 export class WorldSimulation {
     static _cullGenerators = [];
     static _generators = [];
+    static Tools = WorldSimulationTools;
+    static Tasks = WorldSimulationTasks;
     static addDimension(id) {
         WorldSimulationDimensions.addDimension(id);
     }
     static Procedures = {
         InitalLoad,
         SaveAllSectors,
-        BuildOnly,
     };
     static logTasks() {
         return {
@@ -89,14 +91,40 @@ export class WorldSimulation {
         return false;
     }
     static doTickUpdates = true;
-    static tick(generationOnly = false) {
+    static clearAll() {
+        for (const [, dimension] of WorldSimulationDimensions._dimensions) {
+            dimension.clearAll();
+        }
+        WorldSimulationTools.parent.runTask("clear-all", []);
+        const meshers = WorldSimulationTools.taskTool.meshers;
+        if (meshers instanceof Thread) {
+            meshers.runTask("clear-all", []);
+        }
+        else {
+            meshers.runTaskForAll("clear-all", []);
+        }
+        const generators = WorldSimulationTools.taskTool.generators;
+        if (generators instanceof Thread) {
+            generators.runTask("clear-all", []);
+        }
+        else {
+            generators.runTaskForAll("clear-all", []);
+        }
+        WorldRegister.clearAll();
+    }
+    static tick(generationOnly = false, buildOnly = false) {
         let total = 0;
         for (const [, dimension] of WorldSimulationDimensions._dimensions) {
             dimension.incrementTick();
             for (let i = 0; i < dimension.activeSectors._sectors.length; i++) {
                 total += dimension.activeSectors._sectors[i].tickQueue.getTotalTicks();
+                if (buildOnly) {
+                    dimension.activeSectors._sectors[i].updateGenAllDone();
+                }
                 dimension.activeSectors._sectors[i].tickUpdate(this.doTickUpdates);
-                dimension.activeSectors._sectors[i].generateUpdate();
+                if (!buildOnly) {
+                    dimension.activeSectors._sectors[i].generateUpdate();
+                }
             }
         }
         let needActiveSectorUpdate = false;
@@ -111,24 +139,20 @@ export class WorldSimulation {
         if (needActiveSectorUpdate) {
             runActiveSectorUpdate();
         }
-        WorldSimulationTasks.worldLoadTasks.runTask();
-        WorldSimulationTasks.worldGenTasks.runTask();
-        WorldSimulationTasks.worldDecorateTasks.runTask();
-        WorldSimulationTasks.worldSunTasks.runTask();
-        WorldSimulationTasks.worldPropagationTasks.runTask();
-        /*    console.log(
-          "total ticks",
-          total,
-          "building",
-              "building",
-          WorldSimulationTasks.buildTasks.getTotalWaitingFor(0),
-          WorldSimulationTasks.buildTasks.getTotal(0)
-        ); */
+        if (!buildOnly) {
+            WorldSimulationTasks.worldLoadTasks.runTask();
+            WorldSimulationTasks.worldGenTasks.runTask();
+            WorldSimulationTasks.worldDecorateTasks.runTask();
+            WorldSimulationTasks.worldSunTasks.runTask();
+            WorldSimulationTasks.worldPropagationTasks.runTask();
+        }
         if (generationOnly)
             return;
-        WorldSimulationTasks.buildTasks.runTask(32);
-        WorldSimulationTasks.saveTasks.runTask(50);
-        WorldSimulationTasks.unloadTasks.runTask(50);
+        WorldSimulationTasks.buildTasks.runTask(64);
+        if (!buildOnly) {
+            WorldSimulationTasks.saveTasks.runTask(50);
+            WorldSimulationTasks.unloadTasks.runTask(50);
+        }
         WorldSimulationTasks.unbuildTasks.runTask();
     }
 }

package/package.json

@@ -1 +1 @@
-{"name":"@divinevoxel/vlox","version":"0.0.80","description":"Vlox a block style voxel engine.","main":"index.js","types":"index.d.ts","type":"module","devDependencies":{},"scripts":{"clean:dist-ts":"test -d dist && find dist -type f \\( -name \"*.js\" -o -name \"*.d.ts\" \\) -delete || true","build":"mkdir -p dist && npm run clean:dist-ts && cp package.json dist/package.json && cd ./src && npx tsc","prepare-publish":"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","compile:fresh":"npm run clean:dist-ts && cd src && npx tsc --watch"},"keywords":[],"author":"Divine Star Software","license":"MIT","repository":{"url":"git+https://github.com/Divine-Star-Software/DivineVoxelEngine.git"},"bugs":{"url":"https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"},"dependencies":{"@amodx/math":"latest","@amodx/binary":"latest","@amodx/threads":"latest"},"publishConfig":{"access":"public"}}
+{"name":"@divinevoxel/vlox","version":"0.0.81","description":"Vlox a block style voxel engine.","main":"index.js","types":"index.d.ts","type":"module","devDependencies":{},"scripts":{"clean:dist-ts":"test -d dist && find dist -type f \\( -name \"*.js\" -o -name \"*.d.ts\" \\) -delete || true","build":"mkdir -p dist && npm run clean:dist-ts && cp package.json dist/package.json && cd ./src && npx tsc","prepare-publish":"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","compile:fresh":"npm run clean:dist-ts && cd src && npx tsc --watch"},"keywords":[],"author":"Divine Star Software","license":"MIT","repository":{"url":"git+https://github.com/Divine-Star-Software/DivineVoxelEngine.git"},"bugs":{"url":"https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"},"dependencies":{"@amodx/math":"latest","@amodx/binary":"latest","@amodx/threads":"latest"},"publishConfig":{"access":"public"}}

package/Mesher/Items/MeshTextureO.d.ts

@@ -1 +0,0 @@
-export declare function MeshTexture(textureId: number, textureData: number[]): void;

package/Mesher/Items/MeshTextureO.js

@@ -1,277 +0,0 @@
-import { Quad } from "../Geometry/Primitives/Quad";
-const Quads = {
-    north: Quad.Create([
-        [1, 1, 0],
-        [0, 1, 0],
-        [0, 0, 0],
-        [1, 0, 0],
-    ], Quad.FullUVs),
-    south: Quad.Create([
-        [1, 1, 0],
-        [0, 1, 0],
-        [0, 0, 0],
-        [1, 0, 0],
-    ], Quad.FullUVs),
-};
-//const tool = new MesherDataTool();
-//tool.startNewMesh();
-//tool.mesh!.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
-//tool.mesh!.attributes.set("textureIndex", [[], 3, BinaryNumberTypes.Float32]);
-export function MeshTexture(textureId, textureData) {
-    /*  const width = Math.sqrt(textureData.length / 4);
-     const height = Math.sqrt(textureData.length / 4);
-     const factor = 1 / width;
-   
-     const textureDataIndex = Flat2DIndex.GetXYOrder();
-     textureDataIndex.setBounds(width, height);
-   
-     const origin = Vector3Like.Create(-0.5, -0.5, -0.5);
-   
-     const isSolid = (x: number, y: number) =>
-       x >= 0 &&
-       x < width &&
-       y >= 0 &&
-       y < height &&
-       textureData[textureDataIndex.getIndexXY(x, y) * 4 + 3] > 0.01
-         ? true
-         : false;
-   
-     const uvs = tool.mesh!.getAttribute("uv");
-     const textureIndex = tool.mesh!.getAttribute("textureIndex");
-     const uvOffset = width > 16 ? -(2 / Math.max(width, height)) : 0;
-   
-     const addUvs = (sx: number, sy: number, ex: number, ey: number) => {
-       uvs.push(
-         (ex + uvOffset) * factor,
-         (ey + uvOffset) * factor,
-         (sx - uvOffset) * factor,
-         (ey + uvOffset) * factor,
-         (sx - uvOffset) * factor,
-         (sy - uvOffset) * factor,
-         (ex + uvOffset) * factor,
-         (sy - uvOffset) * factor
-       );
-       textureIndex.push(
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0
-       );
-     };
-   
-     {
-       GeometryBuilder.addQuad(tool, origin, Quads.south);
-       uvs.push(
-         Quads.south.uvs.vertices[QuadVerticies.TopRight].x,
-         Quads.south.uvs.vertices[QuadVerticies.TopRight].y,
-         Quads.south.uvs.vertices[QuadVerticies.TopLeft].x,
-         Quads.south.uvs.vertices[QuadVerticies.TopLeft].y,
-         Quads.south.uvs.vertices[QuadVerticies.BottomLeft].x,
-         Quads.south.uvs.vertices[QuadVerticies.BottomLeft].y,
-         Quads.south.uvs.vertices[QuadVerticies.BottomRight].x,
-         Quads.south.uvs.vertices[QuadVerticies.BottomRight].y
-       );
-   
-       textureIndex.push(
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0
-       );
-     }
-   
-     {
-       const backPositionZ = factor;
-       Quads.north.positions.vertices[QuadVerticies.TopRight].z = backPositionZ;
-       Quads.north.positions.vertices[QuadVerticies.TopLeft].z = backPositionZ;
-       Quads.north.positions.vertices[QuadVerticies.BottomLeft].z = backPositionZ;
-       Quads.north.positions.vertices[QuadVerticies.BottomRight].z = backPositionZ;
-       Quads.north.flip = true;
-       uvs.push(
-         Quads.north.uvs.vertices[QuadVerticies.TopLeft].x,
-         Quads.north.uvs.vertices[QuadVerticies.TopLeft].y,
-         Quads.north.uvs.vertices[QuadVerticies.TopRight].x,
-         Quads.north.uvs.vertices[QuadVerticies.TopRight].y,
-         Quads.north.uvs.vertices[QuadVerticies.BottomRight].x,
-         Quads.north.uvs.vertices[QuadVerticies.BottomRight].y,
-         Quads.north.uvs.vertices[QuadVerticies.BottomLeft].x,
-         Quads.north.uvs.vertices[QuadVerticies.BottomLeft].y
-       );
-       GeometryBuilder.addQuad(tool, origin, Quads.north);
-       textureIndex.push(
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0,
-         textureId,
-         0,
-         0
-       );
-     }
-   
-     for (let x = 0; x < width; x++) {
-       let eastFace: Vec2Array | null = null;
-       let westFace: Vec2Array | null = null;
-       for (let y = 0; y < height; y++) {
-         let eastFaceExposed = true;
-         let westFaceExposed = true;
-   
-         if (!isSolid(x, y)) {
-           eastFaceExposed = false;
-           westFaceExposed = false;
-         }
-         if (isSolid(x + 1, y)) {
-           eastFaceExposed = false;
-         }
-         if (isSolid(x - 1, y)) {
-           westFaceExposed = false;
-         }
-   
-         if (eastFace && !eastFaceExposed) {
-           const newQuad = Quad.Create(
-             [
-               [x * factor + factor, eastFace[1] * factor, 0],
-               [x * factor + factor, y * factor, factor],
-             ],
-             Quad.FullUVs as any,
-             false,
-             0
-           );
-           GeometryBuilder.addQuad(tool, origin, newQuad);
-   
-           let [sx, sy] = eastFace;
-           let ex = x;
-           let ey = y;
-           ex += 1;
-           addUvs(sx, sy, ex, ey);
-           eastFace = null;
-         }
-   
-         if (westFace && !westFaceExposed) {
-           const newQuad = Quad.Create(
-             [
-               [x * factor, westFace[1] * factor, 0],
-               [x * factor, y * factor, factor],
-             ],
-             Quad.FullUVs as any,
-             false,
-             1
-           );
-           GeometryBuilder.addQuad(tool, origin, newQuad);
-           let [sx, sy] = westFace;
-           let ex = x;
-           let ey = y;
-           ex += 1;
-           addUvs(sx, sy, ex, ey);
-           westFace = null;
-         }
-         const isPixel = isSolid(x, y);
-         if (!isSolid(x + 1, y) && !eastFace && isPixel) {
-           eastFace = [x, y];
-         }
-         if (!isSolid(x - 1, y) && !westFace && isPixel) {
-           westFace = [x, y];
-         }
-       }
-     }
-     for (let y = 0; y < height; y++) {
-       let upFace: Vec2Array | null = null;
-       let downFace: Vec2Array | null = null;
-   
-       for (let x = 0; x < width; x++) {
-         let upFaceExposed = true;
-         let downFaceExposed = true;
-   
-         if (!isSolid(x, y)) {
-           upFaceExposed = false;
-           downFaceExposed = false;
-         }
-         if (isSolid(x, y + 1)) {
-           upFaceExposed = false;
-         }
-         if (isSolid(x, y - 1)) {
-           downFaceExposed = false;
-         }
-   
-         if (upFace && !upFaceExposed) {
-           const newQuad = Quad.Create(
-             [
-               [upFace[0] * factor, y * factor + factor, 0],
-               [x * factor, y * factor + factor, factor],
-             ],
-             Quad.FullUVs as any,
-             false,
-             0
-           );
-           GeometryBuilder.addQuad(tool, origin, newQuad);
-           let [sx, sy] = upFace;
-           let [ex, ey] = [x, y];
-   
-           ey += 1;
-           addUvs(sx, sy, ex, ey);
-           upFace = null;
-         }
-   
-         if (downFace && !downFaceExposed) {
-           const newQuad = Quad.Create(
-             [
-               [downFace[0] * factor, y * factor, 0],
-               [x * factor, y * factor, factor],
-             ],
-             Quad.FullUVs as any,
-             false,
-             1
-           );
-           GeometryBuilder.addQuad(tool, origin, newQuad);
-           let [sx, sy] = downFace;
-           let [ex, ey] = [x, y];
-           ey += 1;
-           addUvs(sx, sy, ex, ey);
-           downFace = null;
-         }
-   
-         const isPixel = isSolid(x, y);
-         if (!isSolid(x, y + 1) && !upFace && isPixel) {
-           upFace = [x, y];
-         }
-         if (!isSolid(x, y - 1) && !downFace && isPixel) {
-           downFace = [x, y];
-         }
-       }
-     }
-   
-     for (const [key, [data]] of tool.mesh!.attributes) {
-       if (key == "position") {
-         for (let i = 0; i < data.length; i += 3) {
-           (data as any as number[])[i] -= 0.5;
-           (data as any as number[])[i + 1] -= 0.5;
-           (data as any as number[])[i + 2];
-         }
-       }
-     }
-   
-     const compacted = CompactMesh("dve_item", tool);
-     */
-    //  return tool.mesh;
-}

package/Mesher/Voxels/Models/VoxelConstructor.d.ts

@@ -1,8 +0,0 @@
-import { VoxelModelBuilder } from "./VoxelModelBuilder";
-export declare class VoxelConstructor {
-    id: string;
-    builder: VoxelModelBuilder;
-    isModel: true;
-    constructor(id: string, builder: VoxelModelBuilder);
-    process(): boolean;
-}