@divinevoxel/vlox 0.0.5 → 0.0.6

package/Contexts/Base/Remote/InitWorldDataSync.js

@@ -9,11 +9,9 @@ export default function () {
         //  register.dimensions.re(data.id);
     });
     Threads.registerTask(WorldDataSyncIds.SyncSector, (data) => {
-        WorldRegister.setDimension(data[0][0]);
-        WorldRegister.sectors.add(data[0][1], data[0][2], data[0][3], data[1]);
+        WorldRegister.sectors.add(data[0][0], data[0][1], data[0][2], data[0][3], data[1]);
     });
     Threads.registerTask(WorldDataSyncIds.UnSyncSector, (data) => {
-        WorldRegister.setDimension(data[0]);
-        WorldRegister.sectors.remove(data[1], data[2], data[3]);
+        WorldRegister.sectors.remove(data[0], data[1], data[2], data[3]);
     });
 }

package/Contexts/Render/DVERenderThreads.d.ts

@@ -1,7 +1,7 @@
 import { ThreadManager } from "../Base/ThreadManager";
 export declare class DVERenderThreads extends ThreadManager {
     nexus: import("@amodx/threads").Thread;
-    construcotrs: import("@amodx/threads").ThreadPool;
+    constructors: import("@amodx/threads").ThreadPool;
     parent: import("@amodx/threads").Thread;
     world: import("@amodx/threads").Thread;
     constructor();

package/Contexts/Render/DVERenderThreads.js

@@ -2,12 +2,12 @@ import { Threads } from "@amodx/threads";
 import { ThreadManager } from "../Base/ThreadManager";
 export class DVERenderThreads extends ThreadManager {
     nexus = Threads.createThread("nexus");
-    construcotrs = Threads.createThreadPool("constructor");
+    constructors = Threads.createThreadPool("constructor");
     parent = Threads.parent;
     world = Threads.createThread("world");
     constructor() {
         super();
-        this.addThread(this.construcotrs);
+        this.addThread(this.constructors);
         this.addThread(this.parent);
         this.addThread(this.world);
     }

package/Contexts/Render/DivineVoxelEngineRender.js

@@ -25,7 +25,7 @@ export class DivineVoxelEngineRender {
     async clearAll() {
         this.meshRegister.clearAll();
         await this.threads.world.runTaskAsync("clear-all", "");
-        await Promise.all(this.threads.construcotrs
+        await Promise.all(this.threads.constructors
             .getThreads()
             .map((_) => _.runTaskAsync("clear-all", "")));
     }

package/Init/StartRenderer.js

@@ -1,13 +1,13 @@
 import { DivineVoxelEngineRender } from "../Contexts/Render";
 import InitDataGenerator from "../Contexts/Base/Main/InitDataGenerator";
-import { Thread, ThreadPool } from "@amodx/threads";
+import { Threads, Thread, ThreadPool } from "@amodx/threads";
 import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
 import InitRendererTasks from "../Renderer/InitTasks";
 import InitMesher from "../Mesher/InitMesher";
 import { MeshManager } from "../Renderer/MeshManager";
 export async function StartRenderer(initData) {
     const DVER = new DivineVoxelEngineRender();
-    await DVER.TC.init("render", window, "window");
+    await Threads.init("render", window, "window");
     DivineVoxelEngineRender.initialized = true;
     DVER.renderer = initData.renderer;
     MeshManager.sectorMeshes = initData.renderer.sectorMeshes;
@@ -22,7 +22,7 @@ export async function StartRenderer(initData) {
     DVER.threads.setThreadPort(DVER.threads.world.name, initData.worldWorker);
     if (Array.isArray(initData.constructorWorkers) &&
         initData.constructorWorkers[0] instanceof Worker) {
-        DVER.threads.setThreadPort(DVER.threads.construcotrs.name, initData.constructorWorkers);
+        DVER.threads.setThreadPort(DVER.threads.constructors.name, initData.constructorWorkers);
     }
     else {
         throw Error("Supplied data for the Constructor Workers is not correct. Must be path to worker or an array workers.");
@@ -35,7 +35,7 @@ export async function StartRenderer(initData) {
         substances: initData.substances || [],
         materials: initData.materials || [],
     });
-    InitRendererTasks(DVER.threads.construcotrs);
+    InitRendererTasks(DVER.threads.constructors);
     InitWorldDataSync();
     InitMesher(syncData.voxels.materials.palette, syncData.voxels.models);
     for (const thread of DVER.threads._threads) {
@@ -54,7 +54,7 @@ export async function StartRenderer(initData) {
             await thread.runTaskAsync("sync-data", syncData);
         }
     }
-    DVER.threads.world.waitTillTaskExist("sync-data");
+    await DVER.threads.world.waitTillTaskExist("sync-data");
     await DVER.threads.world.runTaskAsync("sync-data", syncData);
     await DVER.renderer.init(DVER);
     return DVER;

package/Math/Indexing.js

@@ -42,15 +42,15 @@ export function GetXZYOrderArrayIndex(positionX, positionY, positionZ, boundsX,
     return positionX + positionY * boundsX + positionZ * boundsX * boundsZ;
 }
 export function GetYXZOrderArrayPositionVec3Array(index, boundsX, boundsY, boundsZ, positionRef = [0, 0, 0]) {
-    positionRef[1] = Math.floor(index / (boundsX * boundsZ)); // Y (most significant)
-    positionRef[0] = Math.floor((index % (boundsX * boundsZ)) / boundsZ); // X (middle)
-    positionRef[2] = index % boundsZ; // Z (least significant)
+    positionRef[1] = index / (boundsX * boundsZ);
+    positionRef[0] = (index % (boundsX * boundsZ)) / boundsZ;
+    positionRef[2] = index % boundsZ;
     return positionRef;
 }
 export function GetYXZOrderArrayPositionVec3(index, boundsX, boundsY, boundsZ, positionRef = Vector3Like.Create()) {
-    positionRef.y = Math.floor(index / (boundsX * boundsZ)); // Y
-    positionRef.x = Math.floor((index % (boundsX * boundsZ)) / boundsZ); // X
-    positionRef.z = index % boundsZ; // Z
+    positionRef.y = index / (boundsX * boundsZ);
+    positionRef.x = (index % (boundsX * boundsZ)) / boundsZ;
+    positionRef.z = index % boundsZ;
     return positionRef;
 }
 export function GetYXZOrderArrayIndex(positionX, positionY, positionZ, boundsX, boundsY, boundsZ) {

package/Mesher/Functions/CompactVoxelMesh.js

@@ -67,20 +67,53 @@ export function CompactVoxelMesh(tools) {
         const tool = tools[i];
         if (!tool.mesh.buffer.length)
             continue;
-        const dataBuffer = new Float32Array(tool.mesh.buffer);
-        const indiciesBuffer = tool.mesh.indicieIndex > 65535
-            ? new Uint32Array(tool.mesh.indices)
-            : new Uint16Array(tool.mesh.indices);
+        const totalVerticies = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexFloatSize;
+        const vertexArray = new Float32Array(totalVerticies);
+        const vertexBuffers = tool.mesh.buffer._buffers;
+        let start = 0;
+        let done = false;
+        for (let i = 0; i < vertexBuffers.length; i++) {
+            const buffer = vertexBuffers[i];
+            for (let j = 0; j < buffer.length; j++) {
+                vertexArray[start] = buffer[j];
+                start++;
+                if (start > totalVerticies) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+        const indiciesArray = tool.mesh.indicieCount > 65535
+            ? new Uint32Array(tool.mesh.indicieCount)
+            : new Uint16Array(tool.mesh.indicieCount);
+        const indiceBuffers = tool.mesh.indices._buffers;
+        start = 0;
+        done = false;
+        for (let i = 0; i < indiceBuffers.length; i++) {
+            const buffer = indiceBuffers[i];
+            for (let j = 0; j < buffer.length; j++) {
+                indiciesArray[start] = buffer[j];
+                start++;
+                if (start > tool.mesh.indicieCount) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
         const minBounds = tool.mesh.minBounds;
         const maxBounds = tool.mesh.maxBounds;
         data[1].push([
             tool.id,
-            dataBuffer,
-            indiciesBuffer,
+            vertexArray,
+            indiciesArray,
             [minBounds.x, minBounds.y, minBounds.z],
             [maxBounds.x, maxBounds.y, maxBounds.z],
         ]);
-        transfers.push(dataBuffer.buffer, indiciesBuffer.buffer);
+        transfers.push(vertexArray.buffer, indiciesArray.buffer);
     }
     return [data, transfers];
 }

package/Mesher/Functions/MeshSection.js

@@ -1,7 +1,7 @@
 //data
 import { WorldSpaces } from "../../World/WorldSpaces.js";
 //tools
-import { VoxelGeometryLookUp } from "../Models/VoxelGeometryLookUp.js";
+import { VoxelGeometryLookUp, } from "../Models/VoxelGeometryLookUp.js";
 import { CompactVoxelMesh } from "./CompactVoxelMesh.js";
 import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SectionCursor } from "../../World/Cursor/SectionCursor.js";
@@ -10,8 +10,10 @@ import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRe
 import { SectionHeightMap } from "../../World/Section/SectionHeightMap.js";
 import { WorldRegister } from "../../World/WorldRegister.js";
 import { VoxelMeshBVHBuilder } from "../Tools/VoxelMeshBVHBuilder";
+import { Vector3Like } from "@amodx/math";
 const sectionCursor = new SectionCursor();
 const worldCursor = new WorldCursor();
+let space;
 const bvhTool = new VoxelMeshBVHBuilder();
 function process(x, y, z) {
     const voxel = sectionCursor.getVoxel(x, y, z);
@@ -49,14 +51,14 @@ function meshVoxel(x, y, z, voxel) {
     mesher.endConstruction();
     mesher.reset();
 }
+const padding = Vector3Like.Create(5, 5, 5);
 export function MeshSection(location) {
+    if (!space)
+        space = VoxelGeometryLookUp.createSpace(WorldSpaces.section.bounds.x + padding.x, WorldSpaces.section.bounds.y + padding.y, WorldSpaces.section.bounds.z + padding.z);
     const [dimension, cx, cy, cz] = location;
-    WorldRegister.setDimension(dimension);
-    const sector = WorldRegister.sectors.get(cx, cy, cz);
+    const sector = WorldRegister.sectors.get(dimension, cx, cy, cz);
     if (!sector)
         return null;
-    // console.log("mesh section", dimension, cx, cy, cz);
-    const meshStart = performance.now();
     const section = sector.getSection(cy);
     SectionHeightMap.setSection(section);
     worldCursor.setFocalPoint(...location);
@@ -66,7 +68,8 @@ export function MeshSection(location) {
     const maxZ = WorldSpaces.section.bounds.z;
     if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
         return null;
-    VoxelGeometryLookUp.start(dimension, location[1], location[2], location[3]);
+    space.start(cx - padding.x, cy - padding.y, cz - padding.z);
+    VoxelGeometryLookUp.start(space);
     bvhTool.reset();
     for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
         RenderedMaterials.meshers[i].bvhTool = bvhTool;
@@ -86,7 +89,6 @@ export function MeshSection(location) {
         SectionHeightMap.setDirty(y, false);
     }
     VoxelGeometryLookUp.stop();
-    const compactStart = performance.now();
     const transfers = [];
     const sectionEffects = [];
     const sections = [location, [], sectionEffects, 0];
@@ -98,8 +100,9 @@ export function MeshSection(location) {
             transfers.push(float.buffer);
             sectionEffects.push([e, float]);
         }
-        if (!mesher.mesh.buffer.length) {
+        if (!mesher.mesh.vertexCount) {
             mesher.resetAll();
+            mesher.bvhTool = null;
             continue;
         }
         meshed.push(mesher);
@@ -108,6 +111,7 @@ export function MeshSection(location) {
     sections[1] = compactMesh;
     for (let i = 0; i < meshed.length; i++) {
         meshed[i].resetAll();
+        meshed[i].bvhTool = null;
     }
     return [sections, [...transfers, ...buffers]];
 }

package/Mesher/Functions/MeshTexture.d.ts

@@ -1 +1 @@
-export declare function MeshTexture(textureId: number, textureData: number[]): import("../Geomtry/Mesh").Mesh | null;
+export declare function MeshTexture(textureId: number, textureData: number[]): import("../Geomtry/VoxelMesh").VoxelMesh | null;

package/Mesher/Functions/MeshVoxel.js

@@ -8,6 +8,7 @@ import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRe
 const templateCursor = new TemplateCursor();
 const voxelCursor = new VoxelCursor();
 templateCursor.setTemplate(new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf)));
+const space = VoxelGeometryLookUp.createSpace(3, 3, 3);
 export function MeshVoxel(rawVoxelData) {
     const voxel = templateCursor.getVoxel(1, 1, 1);
     voxel.copyRaw(rawVoxelData);
@@ -24,7 +25,7 @@ export function MeshVoxel(rawVoxelData) {
     }
     mesher.bvhTool = null;
     mesher.resetAll();
-    VoxelGeometryLookUp.start("main", 0, 0, 0);
+    VoxelGeometryLookUp.start(space);
     mesher.origin.x = -0.5;
     mesher.origin.y = -0.5;
     mesher.origin.z = -0.5;

package/Mesher/Geomtry/Buffers.d.ts

@@ -0,0 +1,19 @@
+export interface VoxelVertexBuffer {
+    [index: number]: number;
+}
+export declare class VoxelVertexBuffer {
+    vertexFloatSize: number;
+    sectorVertexSize: number;
+    _buffers: Float32Array[];
+    constructor(vertexFloatSize: number, sectorVertexSize: number, startingSectorSize?: number);
+    get length(): number;
+}
+export interface VoxelIndiceBuffer {
+    [index: number]: number;
+}
+export declare class VoxelIndiceBuffer {
+    sectorSize: number;
+    _buffers: Uint32Array[];
+    constructor(sectorSize: number, startingSectorSize?: number);
+    get length(): number;
+}

package/Mesher/Geomtry/Buffers.js

@@ -0,0 +1,81 @@
+export class VoxelVertexBuffer {
+    vertexFloatSize;
+    sectorVertexSize;
+    _buffers = [];
+    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 4) {
+        this.vertexFloatSize = vertexFloatSize;
+        this.sectorVertexSize = sectorVertexSize;
+        const sectorSize = vertexFloatSize * sectorVertexSize;
+        for (let i = 0; i < startingSectorSize; i++) {
+            this._buffers.push(new Float32Array(sectorSize));
+        }
+        const array = this;
+        return new Proxy([], {
+            get: (target, property) => {
+                if (property == "length")
+                    return array.length;
+                if (property == "_buffers")
+                    return array._buffers;
+                const index = +property;
+                const bufferIndex = Math.floor(index / sectorSize);
+                if (!array._buffers[bufferIndex])
+                    this._buffers[bufferIndex] = new Float32Array(sectorSize);
+                const arrayIndex = index - bufferIndex * sectorSize;
+                return array._buffers[bufferIndex][arrayIndex];
+            },
+            set: (target, property, value) => {
+                if (property == "length")
+                    return false;
+                const index = +property;
+                const bufferIndex = Math.floor(index / sectorSize);
+                if (!array._buffers[bufferIndex])
+                    array._buffers[bufferIndex] = new Float32Array(sectorSize);
+                const arrayIndex = index - bufferIndex * sectorSize;
+                array._buffers[bufferIndex][arrayIndex] = value;
+                return true;
+            },
+        });
+    }
+    get length() {
+        return this._buffers.length * this.vertexFloatSize;
+    }
+}
+export class VoxelIndiceBuffer {
+    sectorSize;
+    _buffers = [];
+    constructor(sectorSize, startingSectorSize = 4) {
+        this.sectorSize = sectorSize;
+        for (let i = 0; i < startingSectorSize; i++) {
+            this._buffers.push(new Uint32Array(sectorSize));
+        }
+        const array = this;
+        return new Proxy([], {
+            get: (target, property) => {
+                if (property == "length")
+                    return array.length;
+                if (property == "_buffers")
+                    return array._buffers;
+                const index = +property;
+                const bufferIndex = Math.floor(index / sectorSize);
+                if (!array._buffers[bufferIndex])
+                    this._buffers[bufferIndex] = new Uint32Array(sectorSize);
+                const arrayIndex = index - bufferIndex * sectorSize;
+                return array._buffers[bufferIndex][arrayIndex];
+            },
+            set: (target, property, value) => {
+                if (property == "length")
+                    return false;
+                const index = +property;
+                const bufferIndex = Math.floor(index / sectorSize);
+                if (!array._buffers[bufferIndex])
+                    array._buffers[bufferIndex] = new Uint32Array(sectorSize);
+                const arrayIndex = index - bufferIndex * sectorSize;
+                array._buffers[bufferIndex][arrayIndex] = value;
+                return true;
+            },
+        });
+    }
+    get length() {
+        return this._buffers.length * this.sectorSize;
+    }
+}

package/Mesher/Geomtry/Tools/MesherDataTools.d.ts

@@ -1,7 +1,7 @@
-import { Mesh } from "../Mesh.js";
+import { VoxelMesh } from "../VoxelMesh.js";
 export declare class MesherDataTool {
     segments: Map<string, number[]>;
-    mesh: Mesh | null;
-    startNewMesh(mesh?: Mesh): void;
+    mesh: VoxelMesh | null;
+    startNewMesh(mesh?: VoxelMesh): void;
     resetAll(): this;
 }

package/Mesher/Geomtry/Tools/MesherDataTools.js

@@ -1,9 +1,9 @@
-import { Mesh } from "../Mesh.js";
+import { VoxelMesh } from "../VoxelMesh.js";
 export class MesherDataTool {
     segments = new Map();
     mesh = null;
     startNewMesh(mesh) {
-        this.mesh = mesh ? mesh : new Mesh();
+        this.mesh = mesh ? mesh : new VoxelMesh();
     }
     resetAll() {
         this.mesh?.clear();

package/Mesher/Geomtry/VoxelGeometryBuilder.js

@@ -97,12 +97,12 @@ export class VoxelGeometryBuilder {
         const bottomLeftNor = quad.normals.vertices[2];
         const bottomRightNor = quad.normals.vertices[3];
         const indices = tool.mesh.indices;
-        let indIndex = indices.length;
+        let indIndex = tool.mesh.indicieCount;
         let sides = quad.doubleSided ? 2 : 1;
         const flip = quad.flip;
         let orientation = quad.orientation;
         while (sides--) {
-            const baseIndex = tool.mesh.indicieIndex;
+            const baseIndex = tool.mesh.vertexCount;
             if (!flip) {
                 //1
                 structCursor.index = baseIndex;
@@ -235,7 +235,7 @@ export class VoxelGeometryBuilder {
                 indices[indIndex++] = baseIndex + 3;
                 indices[indIndex++] = baseIndex;
             }
-            tool.mesh.indicieIndex += 4;
+            tool.mesh.addVerticies(4, 6);
         }
         structCursor.data = empty;
     }

package/Mesher/Geomtry/VoxelMesh.d.ts

@@ -0,0 +1,13 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./Buffers";
+export declare class VoxelMesh {
+    indicieIndex: number;
+    indicieCount: number;
+    vertexCount: number;
+    minBounds: Vector3Like;
+    maxBounds: Vector3Like;
+    readonly buffer: VoxelVertexBuffer;
+    readonly indices: VoxelIndiceBuffer;
+    addVerticies(count: number, indicesCount: number): void;
+    clear(): void;
+}

package/Mesher/Geomtry/VoxelMesh.js

@@ -0,0 +1,28 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./Buffers";
+import { VoxelMeshVertexStructCursor } from "../Tools/VoxelMeshVertexStructCursor";
+export class VoxelMesh {
+    indicieIndex = 0;
+    indicieCount = 0;
+    vertexCount = 0;
+    minBounds = Vector3Like.Create(Infinity, Infinity, Infinity);
+    maxBounds = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+    buffer = new VoxelVertexBuffer(VoxelMeshVertexStructCursor.VertexFloatSize, 1000);
+    indices = new VoxelIndiceBuffer(1000);
+    addVerticies(count, indicesCount) {
+        this.vertexCount += count;
+        this.indicieCount += indicesCount;
+    }
+    clear() {
+        // this.buffer.length = 0;
+        //this.indices.length = 0;
+        this.indicieCount = 0;
+        this.vertexCount = 0;
+        this.minBounds.x = Infinity;
+        this.minBounds.y = Infinity;
+        this.minBounds.z = Infinity;
+        this.maxBounds.x = -Infinity;
+        this.maxBounds.y = -Infinity;
+        this.maxBounds.z = -Infinity;
+    }
+}

package/Mesher/InitTask.js

@@ -11,9 +11,8 @@ export default function (rendererThread) {
         rendererThread.runTask("set-section", section[0], section[1]);
     });
     Threads.registerTask(TasksIds.BuildSector, (location) => {
-        WorldRegister.setDimension(location[0]);
         const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const sector = WorldRegister.sectors.get(sectorPosition.x, sectorPosition.y, sectorPosition.z);
+        const sector = WorldRegister.sectors.get(location[0], sectorPosition.x, sectorPosition.y, sectorPosition.z);
         if (!sector) {
             console.warn("Tried building a sector that does not exists.", [
                 sectorPosition.x,

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.js

@@ -33,8 +33,8 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
             const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-            const offsetBaseGometry = VoxelGeometryLookUp.geometryCache[hashed];
-            const offsetConditonalGeometry = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+            const offsetBaseGometry = VoxelGeometryLookUp.space.getGeomtry(hashed);
+            const offsetConditonalGeometry = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
             if (offsetBaseGometry) {
                 for (let i = 0; i < offsetBaseGometry.length; i++) {
                     const geoId = offsetBaseGometry[i];
@@ -42,7 +42,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.voxelHash[hashed].isShapeStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], geoId, faceIndex)) {
+                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isShapeStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], geoId, faceIndex)) {
                         return false;
                     }
                 }
@@ -57,7 +57,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.voxelHash[hashed].isCondtionalStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], geoId, faceIndex))
+                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isCondtionalStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], geoId, faceIndex))
                         return false;
                 }
             }
@@ -83,10 +83,10 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 const currentIndex = aoIndexes[positionIndex];
                 const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
                 const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-                if (VoxelGeometryLookUp.noCastAO[hashed] === true)
+                if (VoxelGeometryLookUp.space.noCastAO[hashed] === 1)
                     continue;
-                const baseGeo = VoxelGeometryLookUp.geometryCache[hashed];
-                const conditonalGeo = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+                const baseGeo = VoxelGeometryLookUp.space.getGeomtry(hashed);
+                const conditonalGeo = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
                 if (!baseGeo && !conditonalGeo)
                     continue;
                 let length = 0;

package/Mesher/Models/Nodes/Ruled/QuadVoxelGeometryNode.js

@@ -39,13 +39,13 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
             const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-            const offsetBaseGometry = VoxelGeometryLookUp.geometryCache[hashed];
-            const offsetConditonalGeometry = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+            const offsetBaseGometry = VoxelGeometryLookUp.space.getGeomtry(hashed);
+            const offsetConditonalGeometry = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
             if (offsetBaseGometry) {
                 for (let i = 0; i < offsetBaseGometry.length; i++) {
                     const faceIndex = this.geomtry.cullIndex.getValue(offsetBaseGometry[i], currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.voxelHash[hashed].isShapeStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], offsetBaseGometry[i], faceIndex)) {
+                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isShapeStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], offsetBaseGometry[i], faceIndex)) {
                         return false;
                     }
                 }
@@ -57,7 +57,7 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
                 for (let k = 0; k < cond.length; k++) {
                     const faceIndex = this.geomtry.cullIndex.getValue(cond[k], currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.voxelHash[hashed].isCondtionalStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], cond[i], faceIndex))
+                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isCondtionalStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], cond[i], faceIndex))
                         return false;
                 }
             }
@@ -83,10 +83,10 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
                 const currentIndex = aoIndexes[positionIndex];
                 const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
                 const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-                if (VoxelGeometryLookUp.noCastAO[hashed] === true)
+                if (VoxelGeometryLookUp.space.noCastAO[hashed] === 1)
                     continue;
-                const baseGeo = VoxelGeometryLookUp.geometryCache[hashed];
-                const conditonalGeo = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+                const baseGeo = VoxelGeometryLookUp.space.getGeomtry(hashed);
+                const conditonalGeo = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
                 if (!baseGeo && !conditonalGeo)
                     continue;
                 let length = 0;

package/Mesher/Models/VoxelConstructor.js

@@ -46,8 +46,8 @@ export class VoxelConstructor {
     }
     process(tool) {
         const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x, tool.position.y, tool.position.z);
-        const treeState = VoxelGeometryLookUp.stateCache[hashed];
-        const modState = VoxelGeometryLookUp.modCache[hashed];
+        const treeState = VoxelGeometryLookUp.space.stateCache[hashed];
+        const modState = VoxelGeometryLookUp.space.modCache[hashed];
         if (treeState !== undefined && treeState > -1) {
             const geoLinks = this.data.shapeStateMap[treeState];
             const geometries = this.data.shapeStateGeometryMap[treeState];
@@ -63,7 +63,7 @@ export class VoxelConstructor {
                 }
             }
         }
-        const conditonalTreeState = VoxelGeometryLookUp.conditonalStateCache[hashed];
+        const conditonalTreeState = VoxelGeometryLookUp.space.conditonalStateCache[hashed];
         if (conditonalTreeState !== undefined && conditonalTreeState > -1) {
             const condiotnalNodes = this.data.condiotnalShapeStateMap[conditonalTreeState];
             const condiotnalNodesLength = condiotnalNodes.length;

package/Mesher/Models/VoxelGeometryLookUp.d.ts

@@ -1,19 +1,28 @@
 import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
-import { VoxelConstructor } from "./VoxelConstructor";
-import { Vec3Array } from "@amodx/math";
+import { Vec3Array, Vector3Like } from "@amodx/math";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export declare class VoxelGeometryLookUpSpace {
+    bounds: Vector3Like;
+    foundHash: Uint8Array;
+    voxelHash: Uint16Array;
+    modCache: Int32Array;
+    stateCache: Int32Array;
+    conditonalStateCache: Int32Array;
+    noCastAO: Uint8Array;
+    offset: Vec3Array;
+    constructor(bounds: Vector3Like);
+    start(x: number, y: number, z: number): void;
+    getIndex(x: number, y: number, z: number): number;
+    getConstructor(index: number): import("./VoxelConstructor").VoxelConstructor | null;
+    getGeomtry(index: number): false | number[];
+    getConditionalGeomtry(index: number): false | number[][];
+}
 export declare class VoxelGeometryLookUp {
-    static voxelHash: VoxelConstructor[];
-    static modCache: number[];
-    static stateCache: number[];
-    static conditonalStateCache: number[];
-    static geometryCache: number[][];
-    static conditionalGeometryCache: number[][][];
-    static noCastAO: boolean[];
-    static offset: Vec3Array;
+    static space: VoxelGeometryLookUpSpace | null;
     static voxelCursor: VoxelCursor;
+    static createSpace(x: number, y: number, z: number): VoxelGeometryLookUpSpace;
     static init(): void;
-    static start(dimension: string, x: number, y: number, z: number): void;
+    static start(space: VoxelGeometryLookUpSpace): void;
     static isRulesless(geoId: number): boolean;
     static stop(): void;
     static getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;