@divinevoxel/vlox 0.0.7 → 0.0.72

package/Mesher/Tools/VoxelMesherDataTool.js

@@ -4,25 +4,29 @@ import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces, VoxelFacesArray } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
-import { FaceDataCalc } from "../Models/Common/Calc/FaceDataCalc.js";
+import calculateFaceData from "../Models/Common/Calc/FaceDataCalc.js";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
-import { Vector3Like } from "@amodx/math";
+import { Vector3Like, Vector4Like } from "@amodx/math";
 class VoxelVars {
     faceFlipped = false;
     textureIndex = 0;
+    overlayTextures = Vector4Like.Create();
     light = new QuadScalarVertexData();
     ao = new QuadScalarVertexData();
     animation = new QuadScalarVertexData();
     level = new QuadScalarVertexData();
-    overlayTextures = new QuadScalarVertexData();
     reset() {
         this.faceFlipped = false;
         this.textureIndex = 0;
+        this.overlayTextures.x = 0;
+        this.overlayTextures.y = 0;
+        this.overlayTextures.z = 0;
     }
 }
 export class VoxelMesherDataTool extends MesherDataTool {
     id;
     materialIndex;
+    space;
     voxel;
     nVoxel;
     /**The current world position */
@@ -78,27 +82,47 @@ export class VoxelMesherDataTool extends MesherDataTool {
     };
     _indexStart = 0;
     startConstruction() {
-        this._indexStart = this.mesh.indices.length;
+        this._indexStart = this.mesh.indicieCount;
         this.bounds.min[0] = Infinity;
         this.bounds.min[1] = Infinity;
         this.bounds.min[2] = Infinity;
         this.bounds.max[0] = -Infinity;
         this.bounds.max[1] = -Infinity;
         this.bounds.max[2] = -Infinity;
+        this._boundsUpdate = true;
     }
     endConstruction() {
-        if (this.bounds.min.includes(Infinity) ||
-            this.bounds.max.includes(-Infinity))
-            return false;
+        this.vars.reset();
         if (this.bvhTool) {
-            this.bvhTool.updateVoxel(this.position.x, this.position.y, this.position.z, this._indexStart, this.materialIndex, this.mesh.indices.length, this.bounds.min[0], this.bounds.min[1], this.bounds.min[2], this.bounds.max[0], this.bounds.max[1], this.bounds.max[2]);
+            if (!this._boundsUpdate)
+                return false;
+            this.bvhTool.updateVoxel(this.position.x, this.position.y, this.position.z, this._indexStart, this.materialIndex, this.mesh.indicieCount, this.bounds.min[0], this.bounds.min[1], this.bounds.min[2], this.bounds.max[0], this.bounds.max[1], this.bounds.max[2]);
         }
         return true;
     }
+    _boundsUpdate = false;
+    updateBounds(bounds) {
+        const origin = this.origin;
+        //min
+        if (origin.x + bounds[0][0] < this.bounds.min[0])
+            this.bounds.min[0] = origin.x + bounds[0][0];
+        if (origin.y + bounds[0][1] < this.bounds.min[1])
+            this.bounds.min[1] = origin.y + bounds[0][1];
+        if (origin.z + bounds[0][2] < this.bounds.min[2])
+            this.bounds.min[2] = origin.z + bounds[0][2];
+        //max
+        if (origin.x + bounds[1][0] > this.bounds.max[0])
+            this.bounds.max[0] = origin.x + bounds[1][0];
+        if (origin.y + bounds[1][1] > this.bounds.max[1])
+            this.bounds.max[1] = origin.y + bounds[1][1];
+        if (origin.z + bounds[1][2] > this.bounds.max[2])
+            this.bounds.max[2] = origin.z + bounds[1][2];
+        this._boundsUpdate = true;
+    }
     calculateFaceData(direction) {
         if (this.dataCalculated[direction])
             return true;
-        FaceDataCalc.calculate(direction, this);
+        calculateFaceData(direction, this);
         this.dataCalculated[direction] = true;
     }
     clearCalculatedData() {
@@ -109,10 +133,7 @@ export class VoxelMesherDataTool extends MesherDataTool {
         this.dataCalculated[VoxelFaces.East] = false;
         this.dataCalculated[VoxelFaces.West] = false;
     }
-    reset() {
-        this.vars.reset();
-    }
-    resetAll() {
+    clear() {
         this.vars.reset();
         this.mesh.clear();
         return this;

package/Models/Indexing/VoxelAOResultsIndex.d.ts

@@ -1,12 +1,12 @@
 export type VoxelAOResultsIndexData = {
-    buffer: SharedArrayBuffer;
+    buffer: ArrayBufferLike;
     vertexByteCount: number;
 };
 export declare class VoxelAOResultsIndex {
-    data: VoxelAOResultsIndexData;
-    view: DataView;
+    view: Uint8Array;
+    readonly vertexByteCount: number;
     constructor(data: VoxelAOResultsIndexData);
-    getByteIndex(otherId: number, directionIndex: number): number;
     getValue(otherId: number, directionIndex: number, vertexIndex: number): number;
     setValue(otherId: number, directionIndex: number, vertexIndex: number, value?: number): void;
+    getData(): VoxelAOResultsIndexData;
 }

package/Models/Indexing/VoxelAOResultsIndex.js

@@ -1,20 +1,26 @@
 import { BinaryArrays } from "@amodx/binary/Util/BinaryArrays";
 import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
+const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+function getByteIndex(otherId, directionIndex, vertexByteCount) {
+    return (otherId * vertexByteCount * flatIndexSize + directionIndex * vertexByteCount);
+}
 export class VoxelAOResultsIndex {
-    data;
     view;
+    vertexByteCount;
     constructor(data) {
-        this.data = data;
-        this.view = new DataView(data.buffer);
-    }
-    getByteIndex(otherId, directionIndex) {
-        return (otherId * this.data.vertexByteCount * VoxelRelativeCubeIndex.flatIndex.size +
-            directionIndex * this.data.vertexByteCount);
+        this.vertexByteCount = data.vertexByteCount;
+        this.view = new Uint8Array(data.buffer);
     }
     getValue(otherId, directionIndex, vertexIndex) {
-        return BinaryArrays.getBitArrayIndex(this.view, this.getByteIndex(otherId, directionIndex), vertexIndex);
+        return BinaryArrays.getBitArrayIndex(this.view, getByteIndex(otherId, directionIndex, this.vertexByteCount), vertexIndex);
     }
     setValue(otherId, directionIndex, vertexIndex, value = 1) {
-        BinaryArrays.setBitArrayIndex(this.view, this.getByteIndex(otherId, directionIndex), vertexIndex, value);
+        BinaryArrays.setBitArrayIndex(this.view, getByteIndex(otherId, directionIndex, this.vertexByteCount), vertexIndex, value);
+    }
+    getData() {
+        return {
+            buffer: this.view.buffer,
+            vertexByteCount: this.vertexByteCount,
+        };
     }
 }

package/Models/Indexing/VoxelFaceCullResultsIndex.d.ts

@@ -1,12 +1,12 @@
 export type VoxelFaceCullResultsIndexData = {
-    buffer: SharedArrayBuffer;
+    buffer: ArrayBufferLike;
     faceByteCount: number;
 };
 export declare class VoxelFaceCullResultsIndex {
-    data: VoxelFaceCullResultsIndexData;
     view: Uint16Array;
+    readonly faceByteCount: number;
     constructor(data: VoxelFaceCullResultsIndexData);
-    getByteIndex(otherId: number, directionIndex: number): number;
     getValue(otherId: number, directionIndex: number, faceIndex: number): number;
     setValue(otherId: number, directionIndex: number, faceIndex: number, value?: number): number;
+    getData(): VoxelFaceCullResultsIndexData;
 }

package/Models/Indexing/VoxelFaceCullResultsIndex.js

@@ -1,21 +1,26 @@
 import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
+const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+function getByteIndex(otherId, directionIndex, faceByteCount) {
+    return (otherId * faceByteCount * flatIndexSize + directionIndex * faceByteCount);
+}
 export class VoxelFaceCullResultsIndex {
-    data;
     view;
+    faceByteCount;
     constructor(data) {
-        this.data = data;
         this.view = new Uint16Array(data.buffer);
-    }
-    getByteIndex(otherId, directionIndex) {
-        return (otherId * this.data.faceByteCount * VoxelRelativeCubeIndex.flatIndex.size +
-            directionIndex * this.data.faceByteCount);
+        this.faceByteCount = data.faceByteCount;
     }
     getValue(otherId, directionIndex, faceIndex) {
-        const v = this.view[this.getByteIndex(otherId, directionIndex) + faceIndex];
+        const v = this.view[getByteIndex(otherId, directionIndex, this.faceByteCount) + faceIndex];
         return v == 65535 ? -1 : v;
     }
     setValue(otherId, directionIndex, faceIndex, value = -1) {
-        return (this.view[this.getByteIndex(otherId, directionIndex) + faceIndex] =
-            value);
+        return (this.view[getByteIndex(otherId, directionIndex, this.faceByteCount) + faceIndex] = value);
+    }
+    getData() {
+        return {
+            buffer: this.view.buffer,
+            faceByteCount: this.faceByteCount,
+        };
     }
 }

package/Models/Indexing/VoxelFaceTransparentResultsIndex.d.ts

@@ -4,7 +4,7 @@ export type VoxelFaceTransparentResultsIndexData = {
 };
 export declare class VoxelFaceTransparentResultsIndex {
     data: VoxelFaceTransparentResultsIndexData;
-    view: DataView;
+    view: Uint8Array;
     constructor(data: VoxelFaceTransparentResultsIndexData);
     getValue(modState: number, faceByteIndex: number, faceIndex: number): number;
     setValue(modState: number, faceByteIndex: number, faceIndex: number, value?: number): void;

package/Models/Indexing/VoxelFaceTransparentResultsIndex.js

@@ -4,7 +4,7 @@ export class VoxelFaceTransparentResultsIndex {
     view;
     constructor(data) {
         this.data = data;
-        this.view = new DataView(data.buffer);
+        this.view = new Uint8Array(data.buffer);
     }
     getValue(modState, faceByteIndex, faceIndex) {
         return BinaryArrays.getBitArrayIndex(this.view, this.data.resultsSize * modState + faceByteIndex, faceIndex);

package/Models/Rules/Functions/BuildRules.js

@@ -179,8 +179,8 @@ export function BuildRules(main, geoPalette) {
         }
     }
     return {
-        aoIndex: aoIndex.data,
-        cullIndex: cullIndex.data,
+        aoIndex: aoIndex.getData(),
+        cullIndex: cullIndex.getData(),
         faceCullMap,
         vertexHitMap,
     };

package/Tasks/IWG/Internal/Classes/Generator.js

@@ -26,7 +26,7 @@ export class Generator {
     }
     update() {
         this._positonChanged = false;
-        WorldSpaces.section.getPosition(this.position.x, this.position.y, this.position.z, this._sectorPosition);
+        WorldSpaces.section.getPosition(this.position.x, 0, this.position.z, this._sectorPosition);
         if (!Vector3Like.Equals(this._sectorPosition, this._cachedPosition)) {
             this._positonChanged = true;
             Vector3Like.Copy(this._cachedPosition, this._sectorPosition);

package/Tasks/IWG/Internal/Functions/getSectorState.js

@@ -1,5 +1,4 @@
 import { WorldRegister } from "../../../../World/WorldRegister";
-import { SectorStateStructIds } from "../../../../World/Sector/SectorStructIds";
 import { $2dMooreNeighborhood } from "../../../../Math/CardinalNeighbors";
 import { WorldSpaces } from "../../../../World/WorldSpaces";
 import { Sector } from "../../../../World/index";
@@ -8,7 +7,6 @@ const tempPosition = Vector3Like.Create();
 export function getSectorState(sector, state, segment) {
     state.resset();
     const [cx, cy, cz] = sector.position;
-    Sector.StateStruct.setData(sector.sectorState);
     for (let i = 0; i < $2dMooreNeighborhood.length; i++) {
         const sectorPOS = WorldSpaces.sector.getPosition(cx + $2dMooreNeighborhood[i][0] * WorldSpaces.sector.bounds.x, cy, cz + $2dMooreNeighborhood[i][1] * WorldSpaces.sector.bounds.z, tempPosition);
         if (!segment.vistedMap.has(sectorPOS.x, cy, sectorPOS.z)) {
@@ -24,17 +22,16 @@ export function getSectorState(sector, state, segment) {
             state.allLoaded = false;
             break;
         }
-        Sector.StateStruct.setData(sector.sectorState);
-        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone)) {
+        if (!sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
             state.nWorldGenAllDone = false;
         }
-        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone)) {
+        if (!sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
             state.nDecorAllDone = false;
         }
-        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone)) {
+        if (!sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
             state.nSunAllDone = false;
         }
-        if (!Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone)) {
+        if (!sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
             state.nPropagtionAllDone = false;
         }
     }

package/Tasks/IWG/Internal/Functions/runWorldUpdate.js

@@ -3,7 +3,6 @@ import { getSectorState } from "./getSectorState";
 import { SectorState } from "../Classes/SectorState";
 import { WorldRegister } from "../../../../World/WorldRegister";
 import { Sector } from "../../../../World";
-import { SectorStateStructIds } from "../../../../World/Sector/SectorStructIds";
 import { WorldLock } from "../../../../World/Lock/WorldLock";
 import { IWGTasks } from "../IWGTasks";
 import { IWGDimensions } from "../IWGDimensions";
@@ -41,24 +40,24 @@ export function runWorldUpdate(generators) {
                 continue;
             }
             const state = getSectorState(sector, stateCursor, segment);
-            Sector.StateStruct.setBuffer(sector.buffer);
+            sector.getBitFlag(Sector.FlagIds.isWorldGenDone);
             if (state.allLoaded &&
-                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone)) {
+                !sector.getBitFlag(Sector.FlagIds.isWorldGenDone)) {
                 IWGTasks.worldGenTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nWorldGenAllDone &&
-                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone)) {
+                !sector.getBitFlag(Sector.FlagIds.isWorldDecorDone)) {
                 IWGTasks.worldDecorateTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nDecorAllDone &&
-                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone)) {
+                !sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone)) {
                 IWGTasks.worldPropagationTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }
             if (state.nPropagtionAllDone &&
-                !Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone)) {
+                !sector.getBitFlag(Sector.FlagIds.isWorldSunDone)) {
                 IWGTasks.worldSunTasks.add(generator._dimension, cx, cy, cz);
                 continue;
             }

package/Tasks/IWG/Internal/IWGTasks.js

@@ -1,6 +1,5 @@
 import { WorldRegister } from "../../../World/WorldRegister";
 import { Sector } from "../../../World/index";
-import { SectorStateStructIds } from "../../../World/Sector/SectorStructIds";
 import { IWGTools } from "./IWGTools";
 import { TaskRegister } from "./TaskRegister";
 export class IWGTasks {
@@ -38,15 +37,13 @@ export class IWGTasks {
         id: "generate",
         propagationBlocking: true,
         async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            const sector = WorldRegister.sectors.get(...location);
             if (!sector)
                 throw new Error(`Sector at ${location.toString()} does not exist when attempting generation.`);
-            Sector.StateStruct.setBuffer(sector.buffer);
-            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldGenDone))
+            if (sector.getBitFlag(Sector.FlagIds.isWorldGenDone))
                 return onDone();
             IWGTools.taskTool.generate.run([location, []], null, () => {
-                Sector.StateStruct.setBuffer(sector.buffer);
-                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldGenDone, 1);
+                sector.setBitFlag(Sector.FlagIds.isWorldGenDone, true);
                 onDone();
             });
         },
@@ -58,15 +55,13 @@ export class IWGTasks {
         id: "decorate",
         propagationBlocking: true,
         async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            const sector = WorldRegister.sectors.get(...location);
             if (!sector)
                 throw new Error(`Sector at ${location.toString()} does not exist when attempting decoration.`);
-            Sector.StateStruct.setBuffer(sector.buffer);
-            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldDecorDone))
+            if (sector.getBitFlag(Sector.FlagIds.isWorldDecorDone))
                 return onDone();
             IWGTools.taskTool.decorate.run([location, []], null, () => {
-                Sector.StateStruct.setBuffer(sector.buffer);
-                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldDecorDone, 1);
+                sector.setBitFlag(Sector.FlagIds.isWorldDecorDone, true);
                 onDone();
             });
         },
@@ -78,15 +73,13 @@ export class IWGTasks {
         id: "wolrd_sun",
         propagationBlocking: true,
         async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            const sector = WorldRegister.sectors.get(...location);
             if (!sector)
                 throw new Error(`Sector at ${location.toString()} does not exist when attempting world sun.`);
-            Sector.StateStruct.setBuffer(sector.buffer);
-            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldSunDone))
+            if (sector.getBitFlag(Sector.FlagIds.isWorldSunDone))
                 return onDone();
             IWGTools.taskTool.worldSun.run(location, null, () => {
-                Sector.StateStruct.setBuffer(sector.buffer);
-                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldSunDone, 1);
+                sector.setBitFlag(Sector.FlagIds.isWorldSunDone, true);
                 onDone();
             });
         },
@@ -98,15 +91,13 @@ export class IWGTasks {
         id: "propagation",
         propagationBlocking: true,
         async run(location, onDone) {
-            const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
+            const sector = WorldRegister.sectors.get(...location);
             if (!sector)
                 throw new Error(`Sector at ${location.toString()} does not exist when attempting propagation.`);
-            Sector.StateStruct.setBuffer(sector.buffer);
-            if (Sector.StateStruct.getProperty(SectorStateStructIds.isWorldPropagationDone))
+            if (sector.getBitFlag(Sector.FlagIds.isWorldPropagationDone))
                 return onDone();
             IWGTools.taskTool.propagation.run(location, null, () => {
-                Sector.StateStruct.setBuffer(sector.buffer);
-                Sector.StateStruct.setProperty(SectorStateStructIds.isWorldPropagationDone, 1);
+                sector.setBitFlag(Sector.FlagIds.isWorldPropagationDone, true);
                 onDone();
             });
         },

package/Tasks/Propagation/Flow/FlowManager.d.ts

@@ -1,12 +1,10 @@
 import { BrushTool } from "../../../Tools/Brush/Brush.js";
-import { SubstanceDataTool } from "../../../Tools/Data/SubstanceDataTool.js";
 import { UpdateTask } from "../../Update/UpdateTask.js";
 import { WorldCursor } from "../../../World/index.js";
 export declare class FlowManager {
     static _brush: BrushTool;
     static _sDataTool: WorldCursor;
     static _nDataTool: WorldCursor;
-    static _substanceTool: SubstanceDataTool;
     static setVoxel(tasks: UpdateTask, vox: string, level: number, levelState: number, x: number, y: number, z: number): void;
     static setDimension(dimension: string): void;
     static removeVoxel(tasks: UpdateTask, x: number, y: number, z: number): void;

package/Tasks/Propagation/Flow/FlowManager.js

@@ -1,23 +1,21 @@
 import { BrushTool } from "../../../Tools/Brush/Brush.js";
-import { SubstanceDataTool } from "../../../Tools/Data/SubstanceDataTool.js";
 import { WorldCursor } from "../../../World/index.js";
 export class FlowManager {
     static _brush = new BrushTool();
     static _sDataTool = new WorldCursor();
     static _nDataTool = new WorldCursor();
-    static _substanceTool = new SubstanceDataTool();
     static setVoxel(tasks, vox, level, levelState, x, y, z) {
         /*    this.sunCheck(tasks, x, y, z);
-           SunRemove(tasks);
-           this._brush.setId(vox).setXYZ(x, y, z).paint();
-           this._sDataTool.loadInAt(x, y, z);
-           this._sDataTool
-             .setLevel(level)
-             .setLevelState(levelState)
-             .setLight(this.getAbsorbLight(x, y, z))
-             .commit();
-       
-           SunUpdate(tasks); */
+        SunRemove(tasks);
+        this._brush.setId(vox).setXYZ(x, y, z).paint();
+        this._sDataTool.loadInAt(x, y, z);
+        this._sDataTool
+          .setLevel(level)
+          .setLevelState(levelState)
+          .setLight(this.getAbsorbLight(x, y, z))
+          .commit();
+    
+        SunUpdate(tasks); */
     }
     static setDimension(dimension) {
         // this._sDataTool.setDimension(dimension);
@@ -27,43 +25,44 @@ export class FlowManager {
     }
     static removeVoxel(tasks, x, y, z) {
         /*     for (const n of $3dCardinalNeighbors) {
-              const nx = x + n[0];
-              const ny = y + n[1];
-              const nz = z + n[2];
-              if (!this._nDataTool.loadInAt(nx, ny, nz)) continue;
-        
-              const l = this._nDataTool.getLight();
-        
-              if (l <= 0) continue;
-        
-              if (this.lightData.getS(l) > 0) {
-                tasks.sun.update.push(nx, ny, nz);
-              }
-        
-              if (this.lightData.hasRGBLight(l)) {
-                tasks.rgb.update.push(nx, ny, nz);
-              }
-            }
-            this._nDataTool.loadInAt(x, y, z);
-            const currentLight = this._nDataTool.getLight();
-            this._brush.setXYZ(x, y, z).erase();
-            this._nDataTool.clear().loadInAt(x, y, z);
-            this._nDataTool.setLight(currentLight).commit();
-            tasks.rgb.remove.push(x, y, z);
-            RGBRemove(tasks);
-            SunUpdate(tasks);
-            RGBUpdate(tasks); */
+          const nx = x + n[0];
+          const ny = y + n[1];
+          const nz = z + n[2];
+          if (!this._nDataTool.loadInAt(nx, ny, nz)) continue;
+    
+          const l = this._nDataTool.getLight();
+    
+          if (l <= 0) continue;
+    
+          if (this.lightData.getS(l) > 0) {
+            tasks.sun.update.push(nx, ny, nz);
+          }
+    
+          if (this.lightData.hasRGBLight(l)) {
+            tasks.rgb.update.push(nx, ny, nz);
+          }
+        }
+        this._nDataTool.loadInAt(x, y, z);
+        const currentLight = this._nDataTool.getLight();
+        this._brush.setXYZ(x, y, z).erase();
+        this._nDataTool.clear().loadInAt(x, y, z);
+        this._nDataTool.setLight(currentLight).commit();
+        tasks.rgb.remove.push(x, y, z);
+        RGBRemove(tasks);
+        SunUpdate(tasks);
+        RGBUpdate(tasks); */
     }
     static getFlowRate(substance) {
-        this._substanceTool.setSubstanceFromString(substance);
-        return this._substanceTool.getFlowRate();
+        //  this._substanceTool.setSubstanceFromString(substance);
+        //  return this._substanceTool.getFlowRate();
+        return 0;
     }
     static getVoxel(x, y, z) {
         /*    if (!this._sDataTool.loadInAt(x, y, z)) return false;
-           if (!this._sDataTool.isRenderable()) return false;
-       
-           const substance = this._sDataTool.getSubstnaceData();
-           if (!substance.isLiquid()) return false; */
+        if (!this._sDataTool.isRenderable()) return false;
+    
+        const substance = this._sDataTool.getSubstnaceData();
+        if (!substance.isLiquid()) return false; */
         return this._sDataTool;
     }
     static setLevel(level, x, y, z) {
@@ -72,39 +71,39 @@ export class FlowManager {
     }
     static getLevel(vox, x, y, z) {
         /*    if (!this._nDataTool.loadInAt(x, y, z)) return -2;
-           const voxel = this._nDataTool.getStringId();
-           if (this._nDataTool.isAir()) {
-             return 0;
-           }
-           if (voxel == vox) {
-             return this._nDataTool.getLevel();
-           }
-           return -1; */
+        const voxel = this._nDataTool.getStringId();
+        if (this._nDataTool.isAir()) {
+          return 0;
+        }
+        if (voxel == vox) {
+          return this._nDataTool.getLevel();
+        }
+        return -1; */
     }
     static getLevelState(vox, x, y, z) {
         /*     if (!this._nDataTool.loadInAt(x, y, z)) return -2;
-            const voxel = this._nDataTool.getStringId();
-            if (voxel == vox) {
-              return this._nDataTool.getLevelState();
-            }
-            if (this._nDataTool.isAir()) {
-              return -1;
-            }
-            return -3; */
+        const voxel = this._nDataTool.getStringId();
+        if (voxel == vox) {
+          return this._nDataTool.getLevelState();
+        }
+        if (this._nDataTool.isAir()) {
+          return -1;
+        }
+        return -3; */
     }
     static canFlowOutwardTest(vox, x, y, z) {
         /*    const level = this.getLevel(vox, x, y - 1, z);
-           if (level == -1) {
-             return true;
-           }
-           return false; */
+        if (level == -1) {
+          return true;
+        }
+        return false; */
     }
     static flowDownTest(vox, x, y, z) {
         /*     const level = this.getLevel(vox, x, y - 1, z);
-            if (level >= 0) {
-              return true;
-            }
-            return false; */
+        if (level >= 0) {
+          return true;
+        }
+        return false; */
     }
     static wait(ms) {
         return new Promise((resolve, reject) => setTimeout(resolve, ms));
@@ -114,29 +113,29 @@ export class FlowManager {
     ];
     static getAbsorbLight(x, y, z) {
         /*     for (const n of $3dCardinalNeighbors) {
-              if (!n[0] && !n[1] && !n[2]) continue;
-              if (!this._nDataTool.loadInAt(x + n[0], y + n[1], z + n[2])) continue;
-              let l = this._nDataTool.getLight();
-              if (l <= 0) continue;
-              const v = this.lightData.getLightValues(l);
-              for (let i = 0; i < 4; i++) {
-                if (this._lightValues[i] < v[i]) {
-                  this._lightValues[i] = v[i];
-                }
-              }
+          if (!n[0] && !n[1] && !n[2]) continue;
+          if (!this._nDataTool.loadInAt(x + n[0], y + n[1], z + n[2])) continue;
+          let l = this._nDataTool.getLight();
+          if (l <= 0) continue;
+          const v = this.lightData.getLightValues(l);
+          for (let i = 0; i < 4; i++) {
+            if (this._lightValues[i] < v[i]) {
+              this._lightValues[i] = v[i];
             }
-            let brightest = this.lightData.setLightValues(this._lightValues);
-            for (let i = 0; i < 4; i++) {
-              this._lightValues[i] = 0;
-            } */
+          }
+        }
+        let brightest = this.lightData.setLightValues(this._lightValues);
+        for (let i = 0; i < 4; i++) {
+          this._lightValues[i] = 0;
+        } */
         // return this.lightData.minusOneForAll(2);
     }
     static sunCheck(tasks, x, y, z) {
         /*     if (!this._nDataTool.loadInAt(x, y - 1, z)) return;
-            if (!this._nDataTool.isAir()) return;
-            const l = this._nDataTool.getLight();
-            if (this.lightData.getS(l) == 0xf) {
-              tasks.sun.remove.push(x, y - 1, z);
-            } */
+        if (!this._nDataTool.isAir()) return;
+        const l = this._nDataTool.getLight();
+        if (this.lightData.getS(l) == 0xf) {
+          tasks.sun.remove.push(x, y - 1, z);
+        } */
     }
 }