@divinevoxel/vlox 0.0.2 → 0.0.4

package/Data/World/WorldRegisterCache.js

@@ -1,6 +1,6 @@
 import { WorldBounds } from "../../Data/World/WorldBounds.js";
 import { Vector3Like } from "@amodx/math";
-import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { EngineSettings } from "../../Settings/EngineSettings.js";
 export class WorldRegisterCache {
     _cacheOn = false;
     _chunkCache = [];

package/Data/World/WorldSpaces.d.ts

@@ -1,4 +1,4 @@
 import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
-import type { EngineSettingsData } from "../../Types/EngineSettings.types.js";
+import type { EngineSettingsData } from "../../Settings/EngineSettings.types.js";
 export declare const WorldSpaces: VoxelSpaces;
 export declare function InitWorldSpaces(settings: EngineSettingsData): void;

package/Init/StartConstructor.d.ts

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

package/Init/StartConstructor.js

@@ -1,8 +1,53 @@
-import { DivineVoxelEngineConstructor, } from "../Contexts/Constructor/DivineVoxelEngineConstructor";
-import InitVoxelModels from "../VoxelModels/Constructor/InitVoxelModelsConstructor.js";
-export async function StartContrusctor(data) {
-    const DVEC = new DivineVoxelEngineConstructor(data);
-    await DVEC.init();
-    InitVoxelModels(DVEC);
+import InitDataSync from "../Contexts/Base/Remote/Sync/InitDataSync";
+import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor";
+import { Threads } from "@amodx/threads";
+import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck";
+import { VoxelGeometryLookUp } from "../Mesher/Models/VoxelGeometryLookUp";
+import { Environment } from "@amodx/core/Environment/Environment";
+import { WorldRegister } from "../Data/World/WorldRegister";
+import InitAnalyzerTasks from "../Tasks/Analyzer/InitTasks";
+import InitUpdateTasks from "../Tasks/Update/InitTasks";
+import InitPropagationTasks from "../Tasks/Propagation/InitTasks";
+import InitMesherTasks from "../Tasks/Mesher/InitTasks";
+import InitWorldGenerationTasks from "../Tasks/WorldGeneration/InitTasks";
+import InitWorldDataSync from "../Contexts/Base/Remote/Sync/InitWorldDataSync";
+export async function StartContrusctor(data = {}) {
+    const DVEC = new DivineVoxelEngineConstructor();
+    DivineVoxelEngineConstructor.environment = Environment.nodeJS.isNode
+        ? "node"
+        : "browser";
+    let parent = "render";
+    if (DivineVoxelEngineConstructor.environment == "node") {
+        parent = "server";
+    }
+    await Threads.init("constructor", parent);
+    let ready = false;
+    VoxelGeometryLookUp.init();
+    InitDataSync({
+        onSync(data) {
+            DVEC.mesher.init(data);
+            ready = true;
+        },
+    });
+    Threads.registerTasks("clear-all", () => {
+        WorldRegister.instance.clearAll();
+    });
+    await CreatePromiseCheck({
+        check: () => ready,
+        checkInterval: 1,
+    });
+    InitWorldDataSync();
+    InitAnalyzerTasks();
+    InitPropagationTasks();
+    InitMesherTasks(DVEC.mesher);
+    InitUpdateTasks({
+        onDone(tasks) {
+            DVEC.threads.world.runTasks("build-queue", [
+                tasks.origin[0],
+                tasks.bounds.getChunks(),
+            ]);
+        },
+    });
+    InitWorldGenerationTasks();
     return DVEC;
 }

package/Init/StartNexus.d.ts

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

package/Init/StartNexus.js

@@ -0,0 +1,29 @@
+import InitDataSync from "../Contexts/Base/Remote/Sync/InitDataSync";
+import { DivineVoxelEngineNexus } from "../Contexts/Nexus/DivineVoxelEngineNexus";
+import { Environment } from "@amodx/core/Environment/Environment";
+import { Threads } from "@amodx/threads";
+import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck";
+import InitWorldDataSync from "../Contexts/Base/Remote/Sync/InitWorldDataSync";
+export async function StartNexus(data = {}) {
+    const DVEN = new DivineVoxelEngineNexus(data || {});
+    DivineVoxelEngineNexus.environment = Environment.nodeJS.isNode
+        ? "node"
+        : "browser";
+    let parent = "render";
+    if (DivineVoxelEngineNexus.environment == "node") {
+        parent = "server";
+    }
+    await Threads.init("constructor", parent);
+    let ready = false;
+    InitDataSync({
+        onSync(data) {
+            ready = true;
+        },
+    });
+    InitWorldDataSync();
+    await CreatePromiseCheck({
+        check: () => ready,
+        checkInterval: 1,
+    });
+    return DVEN;
+}

package/Init/StartRenderer.d.ts

@@ -0,0 +1,15 @@
+import { DivineVoxelEngineRender, DVERInitData } from "../Contexts/Render";
+import { VoxelData } from "../Voxels/Voxel.types";
+import { VoxelGeometryData, VoxelModelData } from "../Models/VoxelModel.types";
+import { VoxelSubstanceData } from "Voxels/VoxelSubstances.types";
+type StartRendererProps = {
+    voxels: VoxelData[];
+    geometry?: VoxelGeometryData[];
+    models?: VoxelModelData[];
+    substances?: VoxelSubstanceData[];
+    materials?: {
+        id: string;
+    }[];
+} & DVERInitData;
+export declare function StartRenderer(initData: StartRendererProps): Promise<DivineVoxelEngineRender>;
+export {};

package/Init/StartRenderer.js

@@ -0,0 +1,84 @@
+import { InitVoxelData } from "../Voxels/InitVoxelData";
+import { DivineVoxelEngineRender } from "../Contexts/Render";
+import InitDataGenerator from "../Contexts/Base/Main/Generator/InitDataGenerator";
+import { Thread, ThreadPool } from "@amodx/threads";
+import InitWorldDataSync from "../Contexts/Base/Remote/Sync/InitWorldDataSync";
+export async function StartRenderer(initData) {
+    const DVER = new DivineVoxelEngineRender();
+    DivineVoxelEngineRender.initialized = true;
+    DVER.renderer = initData.renderer;
+    if (initData.nexusWorker) {
+        DVER.threads.nexus.setPort(initData.nexusWorker);
+        DVER.threads.addThread(DVER.threads.nexus);
+    }
+    await DVER.renderer.init(DVER);
+    const t = performance.now();
+    DVER.settings.syncSettings(initData);
+    await DVER.TC.init("render", "global");
+    if (!(initData.worldWorker instanceof Worker)) {
+        throw Error("Supplied data for World Worker is not correct. Must be path to worker or a worker.");
+    }
+    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);
+    }
+    else {
+        throw Error("Supplied data for the Constructor Workers is not correct. Must be path to worker or an array workers.");
+    }
+    const t2 = performance.now();
+    console.log("DONE INIT VOXEL DATA", performance.now() - t2);
+    const syncData = InitDataGenerator({
+        threads: {
+            nexus: initData.nexusWorker ? true : false,
+        },
+        voxels: initData.voxels,
+        substances: initData.substances || [],
+        materials: initData.materials || [],
+        // voxelModels: modelSyncData,
+    });
+    InitWorldDataSync();
+    const modelSyncData = await InitVoxelData({
+        geometry: initData.geometry,
+        models: initData.models,
+        voxels: initData.voxels,
+    });
+    syncData.modelData = modelSyncData;
+    //make sure threads are ready
+    await DVER.threads.world.waitTillTasksExist("sync-data");
+    for (const thread of DVER.threads.construcotrs.getThreads()) {
+        await thread.waitTillTasksExist("sync-data");
+    }
+    //sync threads
+    for (const thread of DVER.threads.construcotrs.getThreads()) {
+        DVER.threads.world.connectToThread(thread);
+    }
+    if (initData.nexusWorker) {
+        DVER.threads.world.connectToThread(DVER.threads.nexus);
+    }
+    //send data to threads
+    for (const thread of DVER.threads.comms) {
+        if (thread instanceof ThreadPool) {
+            for (const com of thread.getThreads()) {
+                com.runTasks("sync-data", syncData);
+            }
+        }
+        if (thread instanceof Thread) {
+            if (thread == DVER.threads.parent)
+                continue;
+            thread.runTasks("sync-data", syncData);
+        }
+    }
+    console.log("DONE INIT DVE", performance.now() - t);
+    window.addEventListener("beforeunload", () => {
+        for (const thread of DVER.threads.comms) {
+            if (thread instanceof ThreadPool) {
+                thread.destroyAll();
+            }
+            if (thread instanceof Thread) {
+                thread.destroy();
+            }
+        }
+    });
+    return DVER;
+}

package/Init/StartWorld.d.ts

@@ -1,7 +1,4 @@
-import type { VoxelData } from "../Types/";
-import { DivineVoxelEngineWorld, DVEWorldProps } from "../Contexts/World/DivineVoxelEngineWorld";
-type StartWorldProps = {
-    voxels: VoxelData[];
-} & DVEWorldProps;
-export declare function StartWorld(props: StartWorldProps): Promise<DivineVoxelEngineWorld>;
+import { DivineVoxelEngineWorld } from "../Contexts/World/DivineVoxelEngineWorld";
+type StartWorldProps = {};
+export declare function StartWorld(props?: StartWorldProps): Promise<DivineVoxelEngineWorld>;
 export {};

package/Init/StartWorld.js

@@ -1,9 +1,133 @@
-import { DivineVoxelEngineWorld, } from "../Contexts/World/DivineVoxelEngineWorld";
-import InitVoxelModelsWorld from "../VoxelModels/World/InitVoxelModelsWorld";
-export async function StartWorld(props) {
+import InitDataSync from "../Contexts/Base/Remote/Sync/InitDataSync";
+import { DivineVoxelEngineWorld } from "../Contexts/World/DivineVoxelEngineWorld";
+import { Threads } from "@amodx/threads/";
+import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck.js";
+import { WorldLock } from "../Contexts/World/Lock/WorldLock";
+import InitWorldTasks from "../Contexts/World/Tasks/WorldTasks";
+import { DataLoaderTool } from "../Tasks/DataLoader/World/Tools/DataLoaderTool";
+import { DataHooks } from "../Contexts/Base/DataHooks";
+import { Chunk, Column, Region } from "../Data/World/Classes";
+import { Environment } from "@amodx/core/Environment/Environment";
+import { VoxelTagStates } from "../Voxels/State/VoxelTagStates";
+import { SchemaRegister } from "../Voxels/State/SchemaRegister";
+import { WorldRegister } from "../Data/World/WorldRegister";
+export async function StartWorld(props = {}) {
+    const register = new WorldRegister();
     const DVEW = new DivineVoxelEngineWorld();
-    InitVoxelModelsWorld(DVEW);
-    DVEW.dataRegiser.voxels.registerData(props.voxels);
-    await DVEW.init();
+    InitWorldTasks(DVEW);
+    DivineVoxelEngineWorld.environment = Environment.nodeJS.isNode
+        ? "node"
+        : "browser";
+    Threads.threadName = "world";
+    let parent = "render";
+    if (DivineVoxelEngineWorld.environment == "node") {
+        parent = "server";
+    }
+    await Threads.init("world", parent);
+    let ready = false;
+    InitDataSync({
+        onSync(data) {
+            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;
+        },
+    });
+    DataHooks.chunk.onGetAsync.regiser("world", async (data) => {
+        data.chunk = Chunk.CreateNew();
+        return data;
+    });
+    DataHooks.chunk.onGetSync.regiser("world", (data) => {
+        data.chunk = Chunk.CreateNew();
+        return data;
+    });
+    DataHooks.chunk.onNew.subscribe("world", (data) => {
+        DVEW.dataSync.worldData.chunk.sync(data);
+    });
+    DataHooks.chunk.onRemove.subscribe("world", (data) => {
+        /*     if (!dataLoaderTool) {
+          DVEW.dataSync.worldData.chunk.unSync(data);
+          return;
+        }
+        dataLoaderTool.setLocation(data).saveColumn(() => {
+          DVEW.dataSync.worldData.chunk.unSync(data);
+        }); */
+    });
+    /*
+  [columns]
+  */
+    DataHooks.column.onGetAsync.regiser("world", async (data) => {
+        data.column = Column.CreateNew({});
+        return data;
+    });
+    DataHooks.column.onGetSync.regiser("world", (data) => {
+        data.column = Column.CreateNew({});
+        return data;
+    });
+    DataHooks.column.onNew.subscribe("world", (data) => {
+        DVEW.dataSync.worldData.column.sync(data);
+    });
+    DataHooks.column.onRemove.subscribe("world", (data) => {
+        /*     if (!dataLoaderTool) {
+        DVEW.dataSync.worldData.column.unSync(data);
+        return;
+      }
+      dataLoaderTool.setLocation(data).saveColumn(() => {
+        DVEW.dataSync.worldData.column.unSync(data);
+      }); */
+    });
+    /*
+  [region]
+  */
+    DataHooks.region.onGetAsync.regiser("world", async (data) => {
+        data.region = Region.CreateNew();
+        return data;
+    });
+    DataHooks.region.onGetSync.regiser("world", (data) => {
+        data.region = Region.CreateNew();
+        return data;
+    });
+    DataHooks.region.onNew.subscribe("world", (data) => {
+        DVEW.dataSync.worldData.region.sync(data);
+    });
+    DataHooks.region.onRemove.subscribe("world", (data) => {
+        /*     if (!dataLoaderTool) {
+      DVEW.dataSync.worldData.column.unSync(data);
+      return;
+    }
+    dataLoaderTool.setLocation(data).saveColumn(() => {
+      DVEW.dataSync.worldData.column.unSync(data);
+    }); */
+    });
+    /*
+  [paint]
+  */
+    DataHooks.paint.onRichVoxelPaint.subscribe("world", (data) => {
+        // DVEW.richworld.setInitalData(data);
+    });
+    /*
+  [dimensions]
+  */
+    DataHooks.dimension.onRegisterDimension.regiser("world", (data) => {
+        DVEW.queues.addQueue(data.id);
+        DVEW.dataSync.worldData.dimesnion.sync(data.id);
+        return data;
+    });
+    WorldLock.init(new DataLoaderTool());
+    await CreatePromiseCheck({
+        check: () => ready,
+        checkInterval: 1,
+    });
+    await DVEW.dataSync.init(DVEW);
     return DVEW;
 }

package/Math/Constants/Faces.d.ts

@@ -1,4 +1,4 @@
-import type { DirectionNames } from "Types/Util.types";
+import type { DirectionNames } from "Util/Util.types";
 import type { CompassDirectionNames } from "Math/Math.types";
 export declare const FaceMap: DirectionNames[];
 export declare const FaceRecord: Record<DirectionNames, number>;

package/Mesher/Functions/CompactMesh.d.ts

@@ -0,0 +1,3 @@
+import { MesherDataTool } from "@amodx/meshing";
+import { CompactMeshData } from "../Types/Mesher.types";
+export declare function CompactMesh(materialId: string, tool: MesherDataTool): CompactMeshData;

package/Mesher/Functions/CompactMesh.js

@@ -0,0 +1,37 @@
+import { MeshDefaultAttributes, } from "@amodx/meshing/MeshData.types";
+import { EngineSettings } from "../../Settings/EngineSettings";
+import { BinaryNumberTypes, TypedArrayClassMap, MappedByteCounts, } from "@amodx/binary";
+export function CompactMesh(materialId, tool) {
+    let webGPU = EngineSettings.settings.rendererSettings.mode == "webgpu";
+    const mesh = tool.mesh;
+    const dataMap = [materialId, []];
+    let totalSize = 0;
+    for (let [key, [array, stride, type]] of mesh.attributes) {
+        if (key == MeshDefaultAttributes.Indices) {
+            if (array.length > 60_000) {
+                type = BinaryNumberTypes.Uint32;
+            }
+        }
+        let current = totalSize;
+        totalSize += MappedByteCounts[type] * array.length;
+        dataMap[1].push([
+            key,
+            {},
+            array.length,
+            current,
+            totalSize,
+            stride,
+            type,
+        ]);
+    }
+    const finalBuffer = new ArrayBuffer(totalSize);
+    for (let data of dataMap[1]) {
+        const [id, n, length, startByte, endByte, stride, type] = data;
+        const newArray = new TypedArrayClassMap[type](finalBuffer, 
+        //@ts-ignore
+        startByte, length);
+        newArray.set(mesh.attributes.get(id)[0]);
+        data[1] = newArray;
+    }
+    return [0, finalBuffer, [dataMap]];
+}

package/Mesher/Functions/CompactVoxelMesh.d.ts

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

package/Mesher/Functions/CompactVoxelMesh.js

@@ -0,0 +1,111 @@
+import { MeshDefaultAttributes, } from "@amodx/meshing/MeshData.types";
+import { EngineSettings } from "../../Settings/EngineSettings";
+import { BinaryNumberTypes, TypedArrayClassMap, MappedByteCounts, } from "@amodx/binary";
+import { VoxelMeshTypes } from "../../Mesher/Types/VoxelMesh.types";
+import { Vector3Like } from "@amodx/math";
+import { VoxelMeshVertexStructCursor } from "../Tools/VoxelMeshVertexStructCursor";
+/**
+struct VoxelMeshVertex {
+    position: vec3<f32>,
+    normal: vec3<f32>,
+    voxelData: f32,
+    textureIndex: vec3<f32>,
+    uv: vec2<f32>,
+    colors: vec3<f32>,
+};
+ */
+const structCursor = new VoxelMeshVertexStructCursor();
+function MakeWebGPUMesh(tool) {
+    const mesh = tool.mesh;
+    const positions = mesh.attributes.get(MeshDefaultAttributes.Position)[0];
+    const normals = mesh.attributes.get(MeshDefaultAttributes.Normal)[0];
+    const voxelData = mesh.attributes.get("voxelData")[0];
+    const textureIndex = mesh.attributes.get("textureIndex")[0];
+    const uv = mesh.attributes.get("uv")[0];
+    const colors = mesh.attributes.get("colors")[0];
+    const indices = mesh.attributes.get(MeshDefaultAttributes.Indices)[0];
+    const numVertices = positions.length / 3;
+    // Create the vertex buffer
+    const finalBuffer = new ArrayBuffer(numVertices * VoxelMeshTypes.vertexStrideBytes);
+    const vertexData = new Float32Array(finalBuffer);
+    structCursor.data = vertexData;
+    for (let i = 0; i < numVertices; i++) {
+        structCursor.index = i;
+        structCursor.positionX = positions[i * 3];
+        structCursor.positionY = positions[i * 3 + 1];
+        structCursor.positionZ = positions[i * 3 + 2];
+        structCursor.normalX = normals[i * 3];
+        structCursor.normalY = normals[i * 3 + 1];
+        structCursor.normalZ = normals[i * 3 + 2];
+        structCursor.voxelData = voxelData[i];
+        structCursor.textureIndexX = textureIndex[i * 3];
+        structCursor.textureIndexY = textureIndex[i * 3 + 1];
+        structCursor.textureIndexZ = textureIndex[i * 3 + 2];
+        structCursor.uvX = uv[i * 2];
+        structCursor.uvY = uv[i * 2 + 1];
+        structCursor.colorR = colors[i * 3];
+        structCursor.colorG = colors[i * 3 + 1];
+        structCursor.colorB = colors[i * 3 + 2];
+    }
+    const indexData = new Uint32Array(indices);
+    for (let i = 0; i < tool.bvhTool.tree.length; i++) {
+        if (tool.bvhTool.tree[i] == -Infinity)
+            tool.bvhTool.tree[i] = -1;
+    }
+    return [
+        1,
+        finalBuffer,
+        indexData,
+        tool.bvhTool.tree.slice(0),
+        tool.bvhTool.indices.slice(0),
+        Vector3Like.ToArray(mesh.minBounds),
+        Vector3Like.ToArray(mesh.maxBounds),
+    ];
+}
+export function CompactVoxelMesh(...tools) {
+    if (EngineSettings.settings.rendererSettings.mode == "webgpu") {
+        throw new Error("WebGPU disabled right now");
+        //    return MakeWebGPUMesh(tool);
+    }
+    const dataMap = [];
+    let totalSize = 0;
+    for (const tool of tools) {
+        const mesh = tool.mesh;
+        const subMesh = [tool.id, []];
+        for (let [key, [array, stride, type]] of mesh.attributes) {
+            if (key == MeshDefaultAttributes.Indices) {
+                if (array.length > 60_000) {
+                    type = BinaryNumberTypes.Uint32;
+                }
+            }
+            let current = totalSize;
+            totalSize += MappedByteCounts[type] * array.length;
+            subMesh[1].push([
+                key,
+                mesh.attributes.get(key)[0],
+                array.length,
+                current,
+                totalSize,
+                stride,
+                type,
+            ]);
+        }
+        for (let i = 0; i < tool.bvhTool.tree.length; i++) {
+            if (tool.bvhTool.tree[i] == -Infinity)
+                tool.bvhTool.tree[i] = -1;
+        }
+        dataMap.push(subMesh);
+    }
+    const finalBuffer = new ArrayBuffer(totalSize);
+    for (let subMesh of dataMap) {
+        for (const data of subMesh[1]) {
+            const [id, n, length, startByte, endByte, stride, type] = data;
+            const newArray = new TypedArrayClassMap[type](finalBuffer, 
+            //@ts-ignore
+            startByte, length);
+            newArray.set(n);
+            data[1] = newArray;
+        }
+    }
+    return [0, finalBuffer, dataMap];
+}

package/Mesher/Geometry/VoxelGeometry.d.ts

@@ -1,6 +1,6 @@
 import { Vector3Like, Vec2Array, Vec3Array } from "@amodx/math";
 import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool";
-import { Quad } from "@amodx/meshing/Classes/Quad";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
 export declare class VoxelGeometry {
     static addTriangle(tool: VoxelMesherDataTool, origin: Vector3Like, points: [Vec3Array, Vec3Array, Vec3Array], [[u1, v1], [u2, v2], [u3, v3]]: [Vec2Array, Vec2Array, Vec2Array]): void;
     static addQuad(tool: VoxelMesherDataTool, origin: Vector3Like, quad: Quad): void;

package/Mesher/Geometry/VoxelGeometry.js

@@ -1,22 +1,24 @@
-import { VoxelShaderData } from "../../Data/VoxelShaderData";
+import { VoxelShaderData } from "../../Voxels/VoxelShaderData";
 import { GeometryBuilder } from "@amodx/meshing/Geometry/GeometryBuilder";
 import { QuadVerticies } from "@amodx/meshing/Geometry.types";
 export class VoxelGeometry {
     static addTriangle(tool, origin, points, [[u1, v1], [u2, v2], [u3, v3]]) {
+        if (!tool.mesh)
+            return;
         const worldLight = tool.getWorldLight();
         const worldAO = tool.getWorldAO();
         const texture = tool.getTexture();
         GeometryBuilder.addTriangle(tool, origin, points);
         {
-            const attribute = tool.getAttribute("voxelData");
+            const attribute = tool.mesh.getAttribute("voxelData");
             attribute.push(VoxelShaderData.createAttribute(worldLight.vertices[1], worldAO.vertices[1], 0), VoxelShaderData.createAttribute(worldLight.vertices[2], worldAO.vertices[2], 0), VoxelShaderData.createAttribute(worldLight.vertices[3], worldAO.vertices[3], 9));
         }
         {
-            const uvs = tool.getAttribute("uv");
+            const uvs = tool.mesh.getAttribute("uv");
             uvs.push(u1, v1, texture, u2, v2, texture, u3, v3, texture);
         }
         {
-            const uvs = tool.getAttribute("textureIndex");
+            const uvs = tool.mesh.getAttribute("textureIndex");
             uvs.push(
             //v1
             0, 0, 0, 0, 
@@ -26,7 +28,7 @@ export class VoxelGeometry {
             0, 0, 0, 0);
         }
         {
-            const colors = tool.getAttribute("colors");
+            const colors = tool.mesh.getAttribute("colors");
             colors.push(
             //v1
             0, 0, 0, 
@@ -37,16 +39,18 @@ export class VoxelGeometry {
         }
     }
     static addQuad(tool, origin, quad) {
+        if (!tool.mesh)
+            return;
         GeometryBuilder.addQuad(tool, origin, quad);
         const worldLight = tool.getWorldLight();
         const worldAO = tool.getWorldAO();
         const animData = tool.getAnimationData();
         const texture = tool.getTexture();
         const overlayTextures = tool.getOverlayTextures();
-        const attribute = tool.getAttribute("voxelData");
-        const uvs = tool.getAttribute("uv");
-        const textureIndex = tool.getAttribute("textureIndex");
-        const colors = tool.getAttribute("colors");
+        const attribute = tool.mesh.getAttribute("voxelData");
+        const uvs = tool.mesh.getAttribute("uv");
+        const textureIndex = tool.mesh.getAttribute("textureIndex");
+        const colors = tool.mesh.getAttribute("colors");
         let sides = quad.doubleSided ? 2 : 1;
         let attrIndex = attribute.length;
         let uvIndex = uvs.length;