@divinevoxel/vlox 0.0.71 → 0.0.72

package/Contexts/Base/Main/InitDataGenerator.js

@@ -1,19 +1,10 @@
-import { InitalizeSectionTags } from "../../../World/Section/SectionStruct.js";
-import { InitalizeSectorTags } from "../../../World/Sector/SectorStruct.js";
 import { EngineSettings } from "../../../Settings/EngineSettings";
-import { Section, Sector } from "../../../World";
 import { InitVoxelData } from "../../../Voxels/InitVoxelData";
 export default function InitDataGenerator(data) {
-    InitalizeSectionTags();
-    InitalizeSectorTags();
     const voxels = InitVoxelData(data);
     return {
         settings: EngineSettings.settings,
         threads: data.threads,
         voxels,
-        worldData: {
-            sectionStruct: Section.StateStruct.structData,
-            sectorStruct: Sector.StateStruct.structData,
-        },
     };
 }

package/Contexts/Base/Remote/DataSync.types.d.ts

@@ -1,5 +1,4 @@
 import { LocationData } from "Math/index.js";
-import { BinaryStructData } from "@amodx/binary";
 import { EngineSettingsData } from "../../../Settings/EngineSettings.types";
 import { CachedVoxelModelData } from "../../../Cache/Cache.types";
 import { CompiledVoxelData } from "../../../Voxels/Types/VoxelModelCompiledData.types";
@@ -10,9 +9,5 @@ export type DataSyncData = {
     threads: {
         nexus: boolean;
     };
-    worldData: {
-        sectionStruct: BinaryStructData;
-        sectorStruct: BinaryStructData;
-    };
 };
 export type WorldDataSync = [location: LocationData, buffer: SharedArrayBuffer];

package/Contexts/Base/Remote/InitDataSync.js

@@ -1,42 +1,28 @@
 import { Threads } from "@amodx/threads/";
-import { VoxelPalette } from "../../../Voxels/Palettes/VoxelPalette";
-import { SubstancePalette } from "../../../Voxels/Palettes/SubstancePalette";
-import { MappedDataRegister } from "../../../Data/Register/MappedDataRegister";
-import { VoxelStruct } from "../../../Voxels/Structs/VoxelStruct";
 import { EngineSettings } from "../../../Settings/EngineSettings";
 //objects
-import { MaterialPalette } from "../../../Voxels/Palettes/MaterialPalette";
-import { Section, Sector } from "../../../World";
-import { SubstanceStruct } from "../../../Voxels/Structs/SubstanceStruct";
+import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
+import { VoxelTagStates } from "../../../Voxels/Data/VoxelTagStates";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
 export default function InitDataSync(props) {
     Threads.registerTask("sync-data", (data) => {
         EngineSettings.syncSettings(data.settings);
-        MaterialPalette.setPalette(data.voxels.materials.palette);
-        //voxels
-        VoxelPalette.loadIn(data.voxels.data.palette, data.voxels.data.nameToIdMap, data.voxels.data.idToNameMap);
-        const voxelStringMaps = MappedDataRegister.stringMaps.getSegment("voxel");
-        for (const key in data.voxels.data.stringMaps) {
-            voxelStringMaps.add(key, data.voxels.data.stringMaps[key]);
+        VoxelPalettesRegister.voxels.load(data.voxels.data.palette);
+        VoxelTagsRegister.VoxelTags = data.voxels.data.tags;
+        VoxelPalettesRegister.voxelIdToNameMap = new Map(data.voxels.data.idToNameMap);
+        VoxelPalettesRegister.voxelNametoIdMap = new Map(data.voxels.data.nameToIdMap);
+        VoxelPalettesRegister.substance.load(data.voxels.substances.palette);
+        VoxelTagsRegister.SubstanceStags = data.voxels.substances.tags;
+        VoxelPalettesRegister.material.load(data.voxels.materials.palette);
+        const modelData = data.voxels.models;
+        for (const model of modelData.models) {
+            SchemaRegister.registerModel(model.id, model.schema);
         }
-        const voxelObjectMaps = MappedDataRegister.objectMaps.getSegment("voxel");
-        for (const key in data.voxels.data.objectMaps) {
-            voxelObjectMaps.add(key, data.voxels.data.objectMaps[key]);
+        for (const voxel of modelData.voxels) {
+            SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
         }
-        VoxelStruct.init(data.voxels.data.struct);
-        VoxelStruct.sync(data.voxels.data.index);
-        //substances
-        SubstancePalette.setPalette(data.voxels.substances.palette);
-        const substanceStringMaps = MappedDataRegister.stringMaps.getSegment("substance");
-        for (const key in data.voxels.substances.stringMaps) {
-            substanceStringMaps.add(key, data.voxels.substances.stringMaps[key]);
-        }
-        const substanceObjectMaps = MappedDataRegister.objectMaps.getSegment("substance");
-        for (const key in data.voxels.substances.objectMaps) {
-            substanceObjectMaps.add(key, data.voxels.substances.objectMaps[key]);
-        }
-        SubstanceStruct.init(data.voxels.substances.struct);
-        Section.StateStruct.init(data.worldData.sectionStruct);
-        Sector.StateStruct.init(data.worldData.sectorStruct);
+        VoxelTagStates.load(modelData.tagState);
         props.onSync(data);
     });
 }

package/Init/StartConstructor.js

@@ -1,7 +1,6 @@
 import InitDataSync from "../Contexts/Base/Remote/InitDataSync";
 import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor";
 import { Threads } from "@amodx/threads";
-import { VoxelGeometryLookUp } from "../Mesher/Models/VoxelGeometryLookUp";
 import { Environment } from "../Util/Environment";
 import { WorldRegister } from "../World/WorldRegister";
 import InitUpdateTasks from "../Tasks/Update/InitTasks";
@@ -22,7 +21,6 @@ export async function StartContrusctor(data = {}) {
     }
     await Threads.init("constructor", self, parent);
     let ready = false;
-    VoxelGeometryLookUp.init();
     InitDataSync({
         onSync(data) {
             InitMesher(data.voxels.materials.palette, data.voxels.models);
@@ -45,8 +43,8 @@ export async function StartContrusctor(data = {}) {
     InitPropagationTasks();
     InitMesherTasks(DVEC.threads.parent);
     InitUpdateTasks({
-        onDone(tasks) {
-            DVEC.threads.world.runTask("build-queue", [
+        onDone(tasks, origin) {
+            origin.runTask("build-queue", [
                 tasks.origin[0],
                 tasks.bounds.getSections(),
             ]);

package/Init/StartWorld.js

@@ -3,8 +3,6 @@ import { DivineVoxelEngineWorld } from "../Contexts/World/DivineVoxelEngineWorld
 import { Threads } from "@amodx/threads/";
 import InitWorldTasks from "../World/InitTasks";
 import { Environment } from "../Util/Environment";
-import { VoxelTagStates } from "../Voxels/State/VoxelTagStates";
-import { SchemaRegister } from "../Voxels/State/SchemaRegister";
 export async function StartWorld(props = {}) {
     const DVEW = new DivineVoxelEngineWorld();
     DivineVoxelEngineWorld.environment = Environment.isNode()
@@ -22,16 +20,6 @@ export async function StartWorld(props = {}) {
             if (data.threads.nexus) {
                 DVEW.threads.addThread(DVEW.threads.nexus);
             }
-            if (data.modelData) {
-                const modelData = data.modelData;
-                for (const model of modelData.models) {
-                    SchemaRegister.registerModel(model.id, model.schema);
-                }
-                for (const voxel of modelData.voxels) {
-                    SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
-                }
-                VoxelTagStates.load(modelData.tagState);
-            }
             ready = true;
         },
     });

package/Math/Indexing.d.ts

@@ -1,12 +1,21 @@
 import { Vec3Array, Vector3Like } from "@amodx/math";
 export declare function CubeHashVec3Array(positionX: number, positionY: number, positionZ: number, xPower2: number, yPower2: number, zPower2: number, positionRef?: Vec3Array): Vec3Array;
 export declare function CubeHashVec3(positionX: number, positionY: number, positionZ: number, xPower2: number, yPower2: number, zPower2: number, positionRef?: Vector3Like): Vector3Like;
+/**
+ * YXZ order
+ */
+export declare function GetYXZOrderArrayPositionVec3Array(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vec3Array): Vec3Array;
+export declare function GetYXZOrderArrayPositionVec3(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vector3Like): Vector3Like;
+export declare function GetYXZOrderArrayIndex(positionX: number, positionY: number, positionZ: number, boundsX: number, boundsY: number, boundsZ: number): number;
+/**
+ * XYZ order
+ */
 export declare function GetXYZOrderArrayPositionVec3Array(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vec3Array): Vec3Array;
 export declare function GetXYZOrderArrayPositionVec3(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vector3Like): Vector3Like;
 export declare function GetXYZOrderArrayIndex(positionX: number, positionY: number, positionZ: number, boundsX: number, boundsY: number, boundsZ: number): number;
 export declare function GetXZYOrderArrayPositionVec3Array(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vec3Array): Vec3Array;
+/**
+ * XZY order
+ */
 export declare function GetXZYOrderArrayPositionVec3(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vector3Like): Vector3Like;
 export declare function GetXZYOrderArrayIndex(positionX: number, positionY: number, positionZ: number, boundsX: number, boundsY: number, boundsZ: number): number;
-export declare function GetYXZOrderArrayPositionVec3Array(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vec3Array): Vec3Array;
-export declare function GetYXZOrderArrayPositionVec3(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vector3Like): Vector3Like;
-export declare function GetYXZOrderArrayIndex(positionX: number, positionY: number, positionZ: number, boundsX: number, boundsY: number, boundsZ: number): number;

package/Math/Indexing.js

@@ -11,6 +11,27 @@ export function CubeHashVec3(positionX, positionY, positionZ, xPower2, yPower2,
     positionRef.z = (positionZ >> zPower2) << zPower2;
     return positionRef;
 }
+/**
+ * YXZ order
+ */
+export function GetYXZOrderArrayPositionVec3Array(index, boundsX, boundsY, boundsZ, positionRef = [0, 0, 0]) {
+    positionRef[1] = Math.floor(index / (boundsX * boundsZ));
+    positionRef[0] = Math.floor((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));
+    positionRef.x = Math.floor((index % (boundsX * boundsZ)) / boundsZ);
+    positionRef.z = index % boundsZ;
+    return positionRef;
+}
+export function GetYXZOrderArrayIndex(positionX, positionY, positionZ, boundsX, boundsY, boundsZ) {
+    return Math.floor(positionZ + boundsZ * (positionX + boundsX * positionY));
+}
+/**
+ * XYZ order
+ */
 export function GetXYZOrderArrayPositionVec3Array(index, boundsX, boundsY, boundsZ, positionRef = [0, 0, 0]) {
     positionRef[2] = index / (boundsX * boundsY);
     positionRef[1] = (index % (boundsX * boundsY)) / boundsX;
@@ -32,6 +53,9 @@ export function GetXZYOrderArrayPositionVec3Array(index, boundsX, boundsY, bound
     positionRef[0] = index % boundsX;
     return positionRef;
 }
+/**
+ * XZY order
+ */
 export function GetXZYOrderArrayPositionVec3(index, boundsX, boundsY, boundsZ, positionRef = Vector3Like.Create()) {
     positionRef.y = index / (boundsX * boundsY);
     positionRef.z = (index % (boundsX * boundsY)) / boundsX;
@@ -41,18 +65,3 @@ export function GetXZYOrderArrayPositionVec3(index, boundsX, boundsY, boundsZ, p
 export function GetXZYOrderArrayIndex(positionX, positionY, positionZ, boundsX, boundsY, boundsZ) {
     return positionX + positionY * boundsX + positionZ * boundsX * boundsZ;
 }
-export function GetYXZOrderArrayPositionVec3Array(index, boundsX, boundsY, boundsZ, positionRef = [0, 0, 0]) {
-    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 = index / (boundsX * boundsZ);
-    positionRef.x = (index % (boundsX * boundsZ)) / boundsZ;
-    positionRef.z = index % boundsZ;
-    return positionRef;
-}
-export function GetYXZOrderArrayIndex(positionX, positionY, positionZ, boundsX, boundsY, boundsZ) {
-    return positionZ + boundsZ * (positionX + boundsX * positionY);
-}

package/Mesher/Functions/CompactVoxelMesh.d.ts

@@ -1,3 +1,3 @@
 import { CompactMeshData } from "../Types/Mesher.types";
 import { VoxelMesherDataTool } from "Mesher/Tools/VoxelMesherDataTool";
-export declare function CompactVoxelMesh(tools: VoxelMesherDataTool[]): [data: CompactMeshData, tranfers: ArrayBuffer[]];
+export declare function CompactVoxelMesh(tools: VoxelMesherDataTool[], transfers?: any[]): CompactMeshData;

package/Mesher/Functions/CompactVoxelMesh.js

@@ -60,12 +60,11 @@ function MakeWebGPUMesh(tool: VoxelMesherDataTool): CompactMeshData {
     Vector3Like.ToArray(mesh.maxBounds),
   ];
 } */
-export function CompactVoxelMesh(tools) {
+export function CompactVoxelMesh(tools, transfers = []) {
     const data = [0, []];
-    const transfers = [];
     for (let i = 0; i < tools.length; i++) {
         const tool = tools[i];
-        if (!tool.mesh.buffer.length)
+        if (!tool.mesh.vertexCount)
             continue;
         const totalVerticies = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexFloatSize;
         const vertexArray = new Float32Array(totalVerticies);
@@ -115,5 +114,5 @@ export function CompactVoxelMesh(tools) {
         ]);
         transfers.push(vertexArray.buffer, indiciesArray.buffer);
     }
-    return [data, transfers];
+    return data;
 }

package/Mesher/Functions/MeshSection.d.ts

@@ -1,3 +1,3 @@
 import { LocationData } from "../../Math";
 import type { SetSectionMeshTask } from "../../Renderer/Renderer.types.js";
-export declare function MeshSection(location: LocationData): [task: SetSectionMeshTask, transfers: any[]] | null;
+export declare function MeshSection(location: LocationData, transfers?: any[]): SetSectionMeshTask | null;

package/Mesher/Functions/MeshSection.js

@@ -1,98 +1,92 @@
 //data
 import { WorldSpaces } from "../../World/WorldSpaces.js";
 //tools
-import { VoxelGeometryLookUp, } from "../Models/VoxelGeometryLookUp.js";
+import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
 import { CompactVoxelMesh } from "./CompactVoxelMesh.js";
 import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SectionCursor } from "../../World/Cursor/SectionCursor.js";
-import { RenderedMaterials } from "../RenderedMaterials";
 import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
-import { SectionHeightMap } from "../../World/Section/SectionHeightMap.js";
 import { WorldRegister } from "../../World/WorldRegister.js";
 import { VoxelMeshBVHBuilder } from "../Tools/VoxelMeshBVHBuilder";
 import { Vector3Like } from "@amodx/math";
+import { RenderedMaterials } from "../../Mesher/RenderedMaterials";
 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);
-    if (!voxel)
-        return false;
-    if (!voxel.isRenderable())
-        return false;
-    if (voxel.hasSecondaryVoxel()) {
-        voxel.setSecondary(true);
-        meshVoxel(x, y, z, voxel);
-        voxel.setSecondary(false);
-    }
-    meshVoxel(x, y, z, voxel);
-    return true;
-}
 function meshVoxel(x, y, z, voxel) {
+    let added = false;
     const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getId()];
-    if (!constructor) {
-        throw new Error(`Could not find constructor ${voxel.getId()} | ${voxel.getName()} `);
-    }
-    const mesher = RenderedMaterials.meshers[voxel.getRenderedMaterial()];
-    if (!mesher) {
-        throw new Error(`Could not find material for ${voxel.getId()} | ${voxel.getName()} | ${constructor?.id} | ${voxel.getMaterial()} | ${voxel.getRenderedMaterialStringId()}`);
-    }
-    mesher.origin.x = sectionCursor._voxelPosition.x;
-    mesher.origin.y = sectionCursor._voxelPosition.y;
-    mesher.origin.z = sectionCursor._voxelPosition.z;
-    mesher.position.x = x;
-    mesher.position.y = y;
-    mesher.position.z = z;
-    mesher.voxel = voxel;
-    mesher.nVoxel = worldCursor;
-    mesher.startConstruction();
-    constructor.process(mesher);
-    mesher.endConstruction();
-    mesher.reset();
+    const builder = constructor.builder;
+    builder.origin.x = sectionCursor._voxelPosition.x;
+    builder.origin.y = sectionCursor._voxelPosition.y;
+    builder.origin.z = sectionCursor._voxelPosition.z;
+    builder.position.x = x;
+    builder.position.y = y;
+    builder.position.z = z;
+    builder.voxel = voxel;
+    builder.nVoxel = worldCursor;
+    builder.startConstruction();
+    added = constructor.process();
+    builder.endConstruction();
+    return added;
 }
 const padding = Vector3Like.Create(5, 5, 5);
-export function MeshSection(location) {
+export function MeshSection(location, transfers = []) {
     if (!space)
-        space = VoxelGeometryLookUp.createSpace(WorldSpaces.section.bounds.x + padding.x, WorldSpaces.section.bounds.y + padding.y, WorldSpaces.section.bounds.z + padding.z);
+        space = new VoxelGeometryBuilderCacheSpace({
+            x: WorldSpaces.section.bounds.x + padding.x,
+            y: WorldSpaces.section.bounds.y + padding.y,
+            z: WorldSpaces.section.bounds.z + padding.z,
+        });
     const [dimension, cx, cy, cz] = location;
     const sector = WorldRegister.sectors.get(dimension, cx, cy, cz);
     if (!sector)
         return null;
     const section = sector.getSection(cy);
-    SectionHeightMap.setSection(section);
     worldCursor.setFocalPoint(...location);
     sectionCursor.setSection(...location);
-    let [minY, maxY] = SectionHeightMap.getMinMax();
-    const maxX = WorldSpaces.section.bounds.x;
-    const maxZ = WorldSpaces.section.bounds.z;
+    let [minY, maxY] = section.getMinMax();
     if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
         return null;
     space.start(cx - (padding.x - 1), cy - (padding.y - 1), cz - (padding.z - 1));
-    VoxelGeometryLookUp.start(space);
     bvhTool.reset();
     const effects = {};
     for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
         const mesher = RenderedMaterials.meshers[i];
+        mesher.space = space;
         mesher.bvhTool = bvhTool;
         mesher.effects = effects;
     }
-    for (let y = minY; y <= maxY; y++) {
-        let foundVoxels = false;
-        if (!SectionHeightMap.getVoxel(y) && !SectionHeightMap.getDirty(y))
-            continue;
-        for (let x = 0; x < maxX; x++) {
-            for (let z = 0; z < maxZ; z++) {
-                let found = process(x + cx, y + cy, z + cz);
-                if (found)
-                    foundVoxels = true;
+    const volume = WorldSpaces.section.volumne;
+    const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
+    //const t = performance.now();
+    for (let i = 0; i < volume; i++) {
+        if (!(i % slice)) {
+            const y = i / slice;
+            if (!section.getHasVoxel(y) && !section.getHasVoxelDirty(y)) {
+                i += slice;
+                continue;
             }
         }
-        SectionHeightMap.setVoxel(y, foundVoxels);
-        SectionHeightMap.setDirty(y, false);
+        if (!section.ids[i] || section.getBuried(i))
+            continue;
+        const voxel = sectionCursor.getVoxelAtIndex(i);
+        const x = cx + sectionCursor._voxelPosition.x;
+        const y = cy + sectionCursor._voxelPosition.y;
+        const z = cz + sectionCursor._voxelPosition.z;
+        let addedVoxel = false;
+        if (meshVoxel(x, y, z, voxel))
+            addedVoxel = true;
+        if (voxel.hasSecondaryVoxel()) {
+            voxel.setSecondary(true);
+            if (meshVoxel(x, y, z, voxel))
+                addedVoxel = true;
+            voxel.setSecondary(false);
+        }
+        section.setBuried(i, !addedVoxel);
     }
-    VoxelGeometryLookUp.stop();
-    const transfers = [];
+    // console.log(performance.now() - t);
     const sectionEffects = [];
     const sections = [location, [], sectionEffects, 0];
     const meshed = [];
@@ -104,17 +98,17 @@ export function MeshSection(location) {
             sectionEffects.push([e, float]);
         }
         if (!mesher.mesh.vertexCount) {
-            mesher.resetAll();
+            mesher.clear();
             mesher.bvhTool = null;
             continue;
         }
         meshed.push(mesher);
     }
-    const [compactMesh, buffers] = CompactVoxelMesh(meshed);
+    const compactMesh = CompactVoxelMesh(meshed, transfers);
     sections[1] = compactMesh;
     for (let i = 0; i < meshed.length; i++) {
-        meshed[i].resetAll();
+        meshed[i].clear();
         meshed[i].bvhTool = null;
     }
-    return [sections, [...transfers, ...buffers]];
+    return sections;
 }

package/Mesher/Functions/MeshVoxel.js

@@ -1,12 +1,11 @@
-import { RenderedMaterials } from "../RenderedMaterials";
-import { VoxelGeometryLookUp } from "../Models/VoxelGeometryLookUp.js";
+import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
 import { TemplateCursor } from "../../Templates/Cursor/TemplateCursor.js";
 import { FullVoxelTemplate } from "../../Templates/FullVoxelTemplate.js";
 import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
 import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
 const templateCursor = new TemplateCursor();
 templateCursor.setTemplate(new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf)));
-const space = VoxelGeometryLookUp.createSpace(3, 3, 3);
+const space = new VoxelGeometryBuilderCacheSpace({ x: 3, y: 3, z: 3 });
 export function MeshVoxel(rawVoxelData) {
     const voxel = templateCursor.getVoxel(1, 1, 1);
     voxel.copyRaw(rawVoxelData);
@@ -17,28 +16,23 @@ export function MeshVoxel(rawVoxelData) {
     if (!constructor) {
         throw new Error(`Could not find constructor for voxel [id:${voxel.getStringId()} name:${voxel.getName()}] `);
     }
-    const mesher = RenderedMaterials.meshersMap.get(voxel.getRenderedMaterialStringId());
-    if (!mesher) {
-        throw new Error(`Could not find material mesh for voxel [id:${voxel.getStringId()} name:${voxel.getName()}] `);
-    }
-    mesher.bvhTool = null;
-    mesher.resetAll();
+    const builder = constructor.builder;
+    builder.space = space;
+    builder.bvhTool = null;
+    builder.clear();
     space.start(0, 0, 0);
-    VoxelGeometryLookUp.start(space);
-    mesher.effects = {};
-    mesher.origin.x = -0.5;
-    mesher.origin.y = -0.5;
-    mesher.origin.z = -0.5;
-    mesher.position.x = 1;
-    mesher.position.y = 1;
-    mesher.position.z = 1;
-    mesher.voxel = voxel;
-    mesher.nVoxel = templateCursor;
-    constructor.process(mesher);
-    mesher.reset();
-    VoxelGeometryLookUp.stop();
-    const compacted = CompactVoxelMesh([mesher]);
-    mesher.reset();
-    mesher.mesh.clear();
-    return compacted;
+    builder.effects = {};
+    builder.origin.x = -0.5;
+    builder.origin.y = -0.5;
+    builder.origin.z = -0.5;
+    builder.position.x = 1;
+    builder.position.y = 1;
+    builder.position.z = 1;
+    builder.voxel = voxel;
+    builder.nVoxel = templateCursor;
+    constructor.process();
+    const transfers = [];
+    const compacted = CompactVoxelMesh([builder], transfers);
+    builder.clear();
+    return [compacted, transfers];
 }

package/Mesher/Geomtry/Buffers.d.ts

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

package/Mesher/Geomtry/Buffers.js

@@ -2,42 +2,27 @@ export class VoxelVertexBuffer {
     vertexFloatSize;
     sectorVertexSize;
     _buffers = [];
+    sectorSize = 0;
     constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 4) {
         this.vertexFloatSize = vertexFloatSize;
         this.sectorVertexSize = sectorVertexSize;
-        const sectorSize = vertexFloatSize * sectorVertexSize;
+        this.sectorSize = vertexFloatSize * sectorVertexSize;
         for (let i = 0; i < startingSectorSize; i++) {
-            this._buffers.push(new Float32Array(sectorSize));
+            this._buffers.push(new Float32Array(this.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;
+    currentArray;
+    curentIndex = 0;
+    _index = 0;
+    setIndex(index) {
+        this._index = index;
+        const bufferIndex = Math.floor((index * this.vertexFloatSize) / this.sectorSize);
+        if (!this._buffers[bufferIndex])
+            this._buffers[bufferIndex] = new Float32Array(this.sectorSize);
+        this.curentIndex =
+            (index * this.vertexFloatSize - bufferIndex * this.sectorSize) /
+                this.vertexFloatSize;
+        this.currentArray = this._buffers[bufferIndex];
     }
 }
 export class VoxelIndiceBuffer {
@@ -48,34 +33,17 @@ export class VoxelIndiceBuffer {
         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;
+    currentArray;
+    curentIndex = 0;
+    _index = 0;
+    setIndex(index) {
+        this._index = index;
+        const bufferIndex = Math.floor(index / this.sectorSize);
+        if (!this._buffers[bufferIndex])
+            this._buffers[bufferIndex] = new Uint32Array(this.sectorSize);
+        this.curentIndex = index - bufferIndex * this.sectorSize;
+        this.currentArray = this._buffers[bufferIndex];
+        return this;
     }
 }

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

@@ -3,5 +3,5 @@ export declare class MesherDataTool {
     segments: Map<string, number[]>;
     mesh: VoxelMesh | null;
     startNewMesh(mesh?: VoxelMesh): void;
-    resetAll(): this;
+    clear(): this;
 }