@divinevoxel/vlox 0.0.72 → 0.0.74

package/Models/Rules/Classes/VoxelRulesModel.d.ts

@@ -2,7 +2,7 @@ import { VoxelModelConstructorData, VoxelModelData } from "../../VoxelModel.type
 import { BuildStateData } from "../../../Voxels/Functions/BuildStateData";
 export declare class VoxelRulesModoel {
     data: VoxelModelData;
-    shapeStates: Map<string, string[]>;
+    states: Map<string, string[]>;
     conditionalNodes: Map<string, string[]>;
     stateData: ReturnType<typeof BuildStateData>;
     voxels: Map<string, VoxelModelConstructorData>;

package/Models/Rules/Classes/VoxelRulesModel.js

@@ -1,6 +1,6 @@
 export class VoxelRulesModoel {
     data;
-    shapeStates = new Map();
+    states = new Map();
     conditionalNodes = new Map();
     stateData;
     voxels = new Map();
@@ -9,10 +9,10 @@ export class VoxelRulesModoel {
         this.data = data;
     }
     registerShapeState(id, geomtryId) {
-        let stateArray = this.shapeStates.get(id);
+        let stateArray = this.states.get(id);
         if (!stateArray) {
             stateArray = [];
-            this.shapeStates.set(id, stateArray);
+            this.states.set(id, stateArray);
         }
         if (!stateArray.find((_) => _ == geomtryId))
             stateArray.push(geomtryId);

package/Models/Rules/Functions/BuildFinalInputs.d.ts

@@ -1,7 +1,7 @@
 import { VoxelFaceTransparentResultsIndex } from "../../Indexing/VoxelFaceTransparentResultsIndex";
 import { VoxelRulesModoel } from "../Classes/VoxelRulesModel";
 export declare function BuildFinalInputs(model: VoxelRulesModoel): {
-    shapeStateVoxelInputs: Record<string, any[]>;
+    stateVoxelInputs: Record<string, any[]>;
     transparentVoxelFaceIndexes: Record<string, VoxelFaceTransparentResultsIndex>;
     conditionalShapeStateVoxelInputs: Record<string, any[]>;
 };

package/Models/Rules/Functions/BuildFinalInputs.js

@@ -1,12 +1,12 @@
 import { VoxelFaceTransparentResultsIndex } from "../../Indexing/VoxelFaceTransparentResultsIndex";
-import { VoxelModelManager } from "../VoxelModelManager";
+import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
 const isArgString = (data) => {
     if (typeof data !== "string")
         return;
     return data[0] == "@";
 };
 export function BuildFinalInputs(model) {
-    const shapeStateVoxelInputs = {};
+    const stateVoxelInputs = {};
     const transparentVoxelFaceIndexes = {};
     const conditionalShapeStateVoxelInputs = {};
     for (const [voxelId, voxel] of model.voxels) {
@@ -20,56 +20,58 @@ export function BuildFinalInputs(model) {
             const modVoxelInput = voxel.inputs[modVoxelInputKey];
             const modIndex = voxelModData.modRecord[modVoxelInputKey];
             const baseStates = [];
-            for (const state in model.data.shapeStatesNodes) {
+            for (const state in model.data.stateNodes) {
                 const geoNodes = [];
-                const shapeStateNodes = model.data.shapeStatesNodes[state];
-                for (const node of shapeStateNodes) {
-                    const geo = VoxelModelManager.getGeomtryFromLink(node);
+                const stateNodes = model.data.stateNodes[state];
+                for (const node of stateNodes) {
+                    const geo = VoxelModelRuleBuilderRegister.getGeomtryFromLink(node);
                     if (!geo)
                         throw new Error(`Geometry does not exist`);
                     geo.inputs.resetDefaults();
                     for (const geoArg in node.inputs) {
                         const constructorArg = node.inputs[geoArg];
                         if (isArgString(constructorArg)) {
-                            geo.inputs[geoArg] = modVoxelInput[constructorArg];
+                            geo.inputs[geoArg] =
+                                modVoxelInput[constructorArg.replace("@", "")];
                             continue;
                         }
                         geo.inputs[geoArg] = constructorArg;
                     }
                     geoNodes[model.stateData.geometryLinkPalette[node.id]] =
                         geo.inputs.cloneArgs();
-                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.shapeStateRelativeGeometryMap[model.stateData.shapeStateRecord[state]][VoxelModelManager.geometryPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))]];
+                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.stateRelativeGeometryMap[model.stateData.stateRecord[state]][VoxelModelRuleBuilderRegister.geometryPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))]];
                     if (geo.data.ogData.doNotBuildRules !== true) {
                         for (let i = 0; i < geo.inputs.faceTransparentIndex.length; i++) {
                             transparentIndex.setValue(modIndex, byteIndex, i, geo.inputs.faceTransparentIndex[i] ? 1 : 0);
                         }
                     }
                 }
-                baseStates[model.stateData.shapeStateRecord[state]] = geoNodes;
+                baseStates[model.stateData.stateRecord[state]] = geoNodes;
             }
-            shapeStateVoxelInputs[voxelId] ??= [];
-            shapeStateVoxelInputs[voxelId][voxelModData.modRecord[modVoxelInputKey]] =
+            stateVoxelInputs[voxelId] ??= [];
+            stateVoxelInputs[voxelId][voxelModData.modRecord[modVoxelInputKey]] =
                 baseStates;
             const condiotnalStates = [];
-            for (const state in model.data.shapeStatesConditonalNodes) {
+            for (const state in model.data.conditonalNodes) {
                 const geoNodes = [];
-                const shapeStateNodes = model.data.shapeStatesConditonalNodes[state];
-                for (let i = 0; i < shapeStateNodes.length; i++) {
-                    const node = shapeStateNodes[i];
-                    const geo = VoxelModelManager.getGeomtryFromLink(node);
+                const stateNodes = model.data.conditonalNodes[state];
+                for (let i = 0; i < stateNodes.length; i++) {
+                    const node = stateNodes[i];
+                    const geo = VoxelModelRuleBuilderRegister.getGeomtryFromLink(node);
                     if (!geo)
                         throw new Error(`Geometry does not exist`);
                     //   geo.inputs.resetDefaults();
                     for (const geoArg in node.inputs) {
                         const constructorArg = node.inputs[geoArg];
                         if (isArgString(constructorArg)) {
-                            geo.inputs[geoArg] = modVoxelInput[constructorArg];
+                            geo.inputs[geoArg] =
+                                modVoxelInput[constructorArg.replace("@", "")];
                             continue;
                         }
                         geo.inputs[geoArg] = constructorArg;
                     }
                     geoNodes[i] = geo.inputs.cloneArgs();
-                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.condiotnalShapeStateRelativeGeometryMap[model.stateData.condiotnalShapeStateRecord[state]][VoxelModelManager.geometryPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))]];
+                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.condiotnalShapeStateRelativeGeometryMap[model.stateData.condiotnalShapeStateRecord[state]][VoxelModelRuleBuilderRegister.geometryPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))]];
                     if (geo.data.ogData.doNotBuildRules !== true) {
                         for (let i = 0; i < geo.inputs.faceTransparentIndex.length; i++) {
                             transparentIndex.setValue(modIndex, byteIndex, i, geo.inputs.faceTransparentIndex[i] ? 1 : 0);
@@ -84,7 +86,7 @@ export function BuildFinalInputs(model) {
         }
     }
     return {
-        shapeStateVoxelInputs,
+        stateVoxelInputs,
         transparentVoxelFaceIndexes,
         conditionalShapeStateVoxelInputs,
     };

package/Models/Rules/Functions/BuildGeomtryInputs.js

@@ -63,6 +63,7 @@ const mapQuadUvs = (uvs, rotation = 0, transform) => {
 export function BuildGeomtryInputs(geomtry) {
     const inputObservers = new Map();
     const onInput = (id, subscribe) => {
+        id = id.replace("@", "");
         let obs = inputObservers.get(id);
         if (!obs) {
             obs = [];
@@ -109,6 +110,7 @@ export function BuildGeomtryInputs(geomtry) {
                         value));
                 }
                 if (isArgString(faceData.transparent)) {
+                    faceTransparentIndex[relativeFaceCount + face] = false;
                     onInput(String(faceData.transparent), (value) => {
                         args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Transparent] = value;
                         faceTransparentIndex[relativeFaceCount + face] = Boolean(value);
@@ -228,15 +230,16 @@ export function BuildGeomtryInputs(geomtry) {
         },
     };
     for (const arg in geomtry.data.ogData.arguments) {
-        const argKey = `@${arg}`;
-        if (!inputObservers.has(argKey))
+        if (!inputObservers.has(arg))
             continue;
-        const obs = inputObservers.get(argKey);
+        const obs = inputObservers.get(arg);
         const data = geomtry.data.ogData.arguments[arg];
-        Object.defineProperty(finalGeoInputs, argKey, {
+        Object.defineProperty(finalGeoInputs, arg, {
             set(value) {
                 if (data.type == "texture") {
-                    value = TextureManager.getTextureIndex(value);
+                    const textureId = value;
+                    value =
+                        TextureManager.getTexture("dve_voxel")?.getTextureIndex(textureId);
                 }
                 for (const func of obs) {
                     func(value);

package/Models/Rules/Functions/BuildRules.js

@@ -1,7 +1,7 @@
 import { VoxelRelativeCubeIndex } from "../../Indexing/VoxelRelativeCubeIndex";
 import { Vector3Like } from "@amodx/math";
 import { VoxelAOResultsIndex } from "../../Indexing/VoxelAOResultsIndex";
-import { VoxelModelManager } from "../VoxelModelManager";
+import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
 import { VoxelFaceCullResultsIndex } from "../../Indexing/VoxelFaceCullResultsIndex";
 class OcculsionBox {
     p1;
@@ -132,7 +132,7 @@ export function BuildRules(main, geoPalette) {
         faceByteCount: main.faceCount,
     });
     for (let otherNumberId = 0; otherNumberId < geoPalette.size; otherNumberId++) {
-        let other = VoxelModelManager.geometry.get(geoPalette._palette[otherNumberId]);
+        let other = VoxelModelRuleBuilderRegister.geometry.get(geoPalette._palette[otherNumberId]);
         if (other.data.ogData.doNotBuildRules !== undefined)
             continue;
         if (other.id == main.id)

package/Models/Rules/{VoxelModelManager.d.ts → VoxelModelRuleBuilderRegister.d.ts}

@@ -2,7 +2,7 @@ import { StringPalette } from "../../Util/StringPalette";
 import { VoxelGeometryData, VoxelGeometryLinkData, VoxelModelConstructorData, VoxelModelData } from "../VoxelModel.types";
 import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
 import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
-export declare class VoxelModelManager {
+export declare class VoxelModelRuleBuilderRegister {
     static geometryPalette: StringPalette;
     static getGeometryLinkId: (node: VoxelGeometryLinkData) => string;
     static voxels: Map<string, {

package/Models/Rules/VoxelModelRuleBuilderRegister.js

@@ -0,0 +1,178 @@
+import { VoxelFaceNameArray } from "../../Math";
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
+import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
+const addGeo = (model, stateId, nodes) => {
+    const registred = [];
+    for (const geoLinkNode of nodes) {
+        const geo = VoxelModelRuleBuilderRegister.geometry.get(geoLinkNode.geometryId);
+        if (!geo)
+            throw new Error(`Geometry ${geoLinkNode.geometryId} is not registered.`);
+        const newId = getGeometryLinkId(geoLinkNode);
+        if (VoxelModelRuleBuilderRegister.geometry.has(newId))
+            continue;
+        registred.push([stateId, newId]);
+        if (!VoxelModelRuleBuilderRegister.geometryPalette.isRegistered(newId))
+            VoxelModelRuleBuilderRegister.geometryPalette.register(newId);
+        const newData = structuredClone(geo.data);
+        for (const node of newData.nodes) {
+            node.tranform = {
+                ...(geoLinkNode.position ? { position: geoLinkNode.position } : {}),
+                ...(geoLinkNode.scale ? { scale: geoLinkNode.scale } : {}),
+                ...(geoLinkNode.rotation ? { rotation: geoLinkNode.rotation } : {}),
+                ...(geoLinkNode.rotationPivot
+                    ? { rotationPivot: geoLinkNode.rotationPivot }
+                    : {}),
+                ...(geoLinkNode.flip ? { flip: geoLinkNode.flip } : {}),
+            };
+        }
+        VoxelModelRuleBuilderRegister.geometry.set(newId, new VoxelRuleGeometry(newId, newData));
+        continue;
+    }
+    return registred;
+};
+const getGeometryLinkId = (node) => {
+    return `${node.geometryId}${node.position ? `-p${node.position.toString()}` : ""}${node.rotation ? `-r${node.rotation.toString()}` : ""}${node.scale ? `-s${node.scale.toString()}` : ""}`.trim();
+};
+export class VoxelModelRuleBuilderRegister {
+    static geometryPalette = new StringPalette();
+    static getGeometryLinkId = getGeometryLinkId;
+    static voxels = new Map();
+    static geometry = new Map();
+    static models = new Map();
+    static registerGeometry(...geometry) {
+        for (const geo of geometry) {
+            if (!this.geometryPalette.isRegistered(geo.id))
+                this.geometryPalette.register(geo.id);
+            const divisor = geo.divisor ? geo.divisor : false;
+            if (divisor) {
+                for (const node of geo.nodes) {
+                    if (node.type == "box") {
+                        let d = node.divisor ? node.divisor : divisor;
+                        node.points[0][0] /= d[0];
+                        node.points[0][1] /= d[1];
+                        node.points[0][2] /= d[2];
+                        node.points[1][0] /= d[0];
+                        node.points[1][1] /= d[1];
+                        node.points[1][2] /= d[2];
+                        for (const faceName of VoxelFaceNameArray) {
+                            const data = node.faces[faceName];
+                            if (Array.isArray(data.uv)) {
+                                data.uv[0] /= d[0];
+                                data.uv[1] /= d[1];
+                                data.uv[2] /= d[0];
+                                data.uv[3] /= d[1];
+                            }
+                        }
+                    }
+                    if (node.type == "quad") {
+                        let d = node.divisor ? node.divisor : divisor;
+                        for (let i = 0; i < 4; i++) {
+                            const point = node.points[i];
+                            point[0] /= d[0];
+                            point[1] /= d[1];
+                            point[2] /= d[2];
+                        }
+                        if (Array.isArray(node.uv)) {
+                            if (Array.isArray(node.uv[0])) {
+                                let uvs = node.uv;
+                                for (let i = 0; i < node.uv.length; i++) {
+                                    uvs[i][0] /= d[0];
+                                    uvs[i][1] /= d[1];
+                                }
+                            }
+                            else {
+                                let uvs = node.uv;
+                                uvs[0] /= d[0];
+                                uvs[1] /= d[1];
+                                uvs[2] /= d[0];
+                                uvs[3] /= d[1];
+                            }
+                        }
+                    }
+                }
+            }
+            this.geometry.set(geo.id, new VoxelRuleGeometry(geo.id, {
+                ogData: geo,
+                id: geo.id,
+                nodes: geo.nodes.map((node) => ({
+                    node,
+                    tranform: {},
+                })),
+            }));
+        }
+    }
+    static getGeomtryFromLink(link) {
+        return this.geometry.get(getGeometryLinkId(link));
+    }
+    static registerModels(...models) {
+        for (const model of models) {
+            const rulesModel = new VoxelRulesModoel(model);
+            this.models.set(model.id, rulesModel);
+            const divisor = model.divisor ? model.divisor : null;
+            if (divisor) {
+                for (const stateId in model.stateNodes) {
+                    const nodes = model.stateNodes[stateId];
+                    for (const node of nodes) {
+                        const d = "divisor" in node ? node.divisor : divisor;
+                        if (node.position) {
+                            node.position[0] /= d[0];
+                            node.position[1] /= d[1];
+                            node.position[2] /= d[2];
+                        }
+                        if (node.rotationPivot) {
+                            node.rotationPivot[0] /= d[0];
+                            node.rotationPivot[1] /= d[1];
+                            node.rotationPivot[2] /= d[2];
+                        }
+                    }
+                }
+                for (const stateId in model.conditonalNodes) {
+                    const nodes = model.conditonalNodes[stateId];
+                    for (const node of nodes) {
+                        const d = "divisor" in node ? node.divisor : divisor;
+                        if (node.position) {
+                            node.position[0] /= d[0];
+                            node.position[1] /= d[1];
+                            node.position[2] /= d[2];
+                        }
+                        if (node.rotationPivot) {
+                            node.rotationPivot[0] /= d[0];
+                            node.rotationPivot[1] /= d[1];
+                            node.rotationPivot[2] /= d[2];
+                        }
+                    }
+                }
+                if (model.effects) {
+                    for (const effect of model.effects) {
+                        if (effect.type == "fx-points") {
+                            for (const state in effect.values) {
+                                for (const point of effect.values[state]) {
+                                    point[0] /= divisor[0];
+                                    point[1] /= divisor[1];
+                                    point[2] /= divisor[2];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            for (const stateId in model.stateNodes) {
+                const nodes = model.stateNodes[stateId];
+                addGeo(model, stateId, nodes).forEach((_) => rulesModel.registerShapeState(..._));
+            }
+            for (const stateId in model.conditonalNodes) {
+                const nodes = model.conditonalNodes[stateId];
+                addGeo(model, stateId, nodes).forEach((_) => rulesModel.registerCondiotnalNode(..._));
+            }
+        }
+    }
+    static registerVoxel(id, data) {
+        let voxelModels = this.voxels.get(data.id);
+        if (!voxelModels) {
+            voxelModels = [];
+            this.voxels.set(data.id, voxelModels);
+        }
+        voxelModels.push({ id, data });
+    }
+}

package/Models/VoxelModel.types.d.ts

@@ -22,6 +22,8 @@ export interface VoxelCustomGeomtryNode {
 }
 export interface VoxelBoxGeometryNode {
     type: "box";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
     noShade?: boolean;
     points: [start: Vec3Array, end: Vec3Array];
     rotation?: Vec3Array;
@@ -37,6 +39,8 @@ export interface VoxelBoxFaceData {
 }
 export interface VoxelQuadGeometryNode {
     type: "quad";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
     doubleSided?: boolean | string;
     points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array];
     transparent?: boolean | string;
@@ -46,6 +50,8 @@ export interface VoxelQuadGeometryNode {
 }
 export interface VoxelTriangleGeometryNode {
     type: "triangle";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
     orientation?: 0 | 1;
     doubleSided?: boolean;
     points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array];
@@ -91,6 +97,7 @@ export type VoxelGeometryNodes = VoxelCustomGeomtryNode | VoxelBoxGeometryNode |
 export interface VoxelGeometryData {
     id: string;
     nodes: VoxelGeometryNodes[];
+    divisor?: Vec3Array;
     /**
      * If this is set the voxel geometry will not be included in the
      * geometry rules and will be fall back to custom inputs.
@@ -99,7 +106,11 @@ export interface VoxelGeometryData {
     doNotBuildRules?: true;
     arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
 }
-export interface VoxelGeometryBaseLinkData {
+export interface VoxelGeometryLinkData {
+    id: string;
+    geometryId: string;
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
     inputs: Record<string, any>;
     scale?: Vec3Array;
     position?: Vec3Array;
@@ -107,16 +118,14 @@ export interface VoxelGeometryBaseLinkData {
     rotationPivot?: Vec3Array;
     flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
 }
-export interface VoxelGeometryLinkData extends VoxelGeometryBaseLinkData {
-    id: string;
-    geometryId: string;
-}
 export interface VoxelModelData {
     id: string;
+    /**Divisor used all transforms of geometry nodes. */
+    divisor?: Vec3Array;
     arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
-    shapeStateSchema: (VoxelStateStringSchemaData | VoxelStateNumberSchemaData)[];
+    stateSchema: (VoxelStateStringSchemaData | VoxelStateNumberSchemaData)[];
     effects?: VoxelEffectData[];
     relationsSchema: VoxelModelRelationsSchemaData[];
-    shapeStatesNodes: Record<string, VoxelGeometryLinkData[]>;
-    shapeStatesConditonalNodes: Record<string, VoxelGeometryLinkData[]>;
+    stateNodes: Record<string, VoxelGeometryLinkData[]>;
+    conditonalNodes: Record<string, VoxelGeometryLinkData[]>;
 }

package/Renderer/Classes/DVESectionMeshes.d.ts

@@ -1,7 +1,6 @@
-import { Vec3Array } from "@amodx/math";
-import { CompactMeshData } from "../../Mesher/Types/Mesher.types";
 import { SectionMesh } from "./SectionMesh";
+import { CompactedSectionVoxelMesh } from "../../Mesher/Geomtry/CompactedSectionVoxelMesh";
 export declare abstract class DVESectionMeshes {
-    abstract updateVertexData(section: SectionMesh, position: Vec3Array, data: CompactMeshData): SectionMesh;
+    abstract updateVertexData(section: SectionMesh, data: CompactedSectionVoxelMesh): SectionMesh;
     abstract returnMesh(mesh: any): void;
 }

package/Renderer/Classes/SectorMesh.d.ts

@@ -4,8 +4,7 @@ export declare class SectorMesh {
     location: LocationData;
     sections: SectionMesh[];
     constructor(location: LocationData);
-    getIndex(y: number): number;
-    getSection(y: number): SectionMesh;
-    addSection(y: number): SectionMesh;
-    removeSection(y: number): false | SectionMesh;
+    getSection(x: number, y: number, z: number): SectionMesh;
+    addSection(x: number, y: number, z: number): SectionMesh;
+    removeSection(x: number, y: number, z: number): false | SectionMesh;
 }

package/Renderer/Classes/SectorMesh.js

@@ -6,24 +6,19 @@ export class SectorMesh {
     constructor(location) {
         this.location = location;
     }
-    getIndex(y) {
-        const ry = y - this.location[2];
-        const index = ry / WorldSpaces.section.bounds.y;
-        return index;
+    getSection(x, y, z) {
+        return this.sections[WorldSpaces.section.getIndex(x, y, z)];
     }
-    getSection(y) {
-        return this.sections[this.getIndex(y)];
-    }
-    addSection(y) {
-        const index = this.getIndex(y);
+    addSection(x, y, z) {
+        const index = WorldSpaces.section.getIndex(x, y, z);
         if (this.sections[index])
             return this.sections[index];
         const section = new SectionMesh(this, index);
         this.sections[index] = section;
         return section;
     }
-    removeSection(y) {
-        const index = this.getIndex(y);
+    removeSection(x, y, z) {
+        const index = WorldSpaces.section.getIndex(x, y, z);
         if (!this.sections[index])
             return false;
         const section = this.sections[index];

package/Renderer/InitTasks.js

@@ -7,17 +7,8 @@ export default function RendererTasks(threads) {
     const tasks = new TaskTool(threads);
     Threads.registerTask("set-section", (data, origin) => {
         MeshManager.updateSection(data);
-        const tranfers = [];
-        for (const comp of data[1]) {
-            if (comp[0] !== 0)
-                continue;
-            for (const mesh of comp[1]) {
-                tranfers.push(mesh[1]);
-                tranfers.push(mesh[2]);
-            }
-        }
         if (!EngineSettings.settings.rendererSettings.cpuBound) {
-            origin.sendMessage(data, tranfers);
+            origin.sendMessage([], [data]);
         }
     });
     Threads.registerTask("remove-sector", (data) => {

package/Renderer/MeshManager.d.ts

@@ -1,4 +1,4 @@
-import { SetSectionMeshTask } from "../Renderer/Renderer.types";
+import type { SetSectionMeshTask } from "../Mesher/Types/Mesher.types";
 import { LocationData } from "../Math/index.js";
 import { DVESectionMeshes } from "./Classes/DVESectionMeshes";
 export declare class MeshManager {

package/Renderer/MeshManager.js

@@ -1,45 +1,46 @@
 import { MeshRegister } from "./MeshRegister.js";
-import { VoxelEffectRegister } from "../Voxels/Effects/VoxelEffectRegister.js";
+import { CompactedSectionVoxelMesh, } from "../Mesher/Geomtry/CompactedSectionVoxelMesh";
 const added = new Set();
+const compacted = new CompactedSectionVoxelMesh();
+const location = [0, 0, 0, 0];
 export class MeshManager {
     static sectorMeshes;
     static runningUpdate = false;
     static updateSection(data) {
-        const location = data[0];
-        const sections = data[1];
-        const effects = data[2];
+        compacted.setData(data);
+        compacted.getLocation(location);
         let sector = MeshRegister.sectors.get(location);
         if (!sector) {
             sector = MeshRegister.sectors.add(location);
         }
-        let section = sector.getSection(location[2]);
+        let section = sector.getSection(location[1], location[2], location[3]);
         if (!section) {
-            section = sector.addSection(location[2]);
+            section = sector.addSection(location[1], location[2], location[3]);
         }
+        /*
         added.clear();
         for (const [id, points] of effects) {
-            added.add(id);
-            if (!section.effects.has(id)) {
-                const EffectClass = VoxelEffectRegister.get(id);
-                const newEffect = new EffectClass(section);
-                newEffect.init();
-                newEffect.setPoints(points);
-                section.effects.set(id, newEffect);
-            }
-            else {
-                const effect = section.effects.get(id);
-                effect.setPoints(points);
-            }
+          added.add(id);
+          if (!section.effects.has(id)) {
+            const EffectClass = VoxelEffectRegister.get(id);
+            const newEffect = new EffectClass(section);
+            newEffect.init();
+            newEffect.setPoints(points);
+            section.effects.set(id, newEffect);
+          } else {
+            const effect = section.effects.get(id)!;
+            effect.setPoints(points);
+          }
         }
         for (const [key, effect] of section.effects) {
-            if (!added.has(key)) {
-                effect.dispose();
-                section.effects.delete(key);
-            }
-        }
-        if (sections[0] == 0) {
-            this.sectorMeshes.updateVertexData(section, [location[1], location[2], location[3]], sections);
+          if (!added.has(key)) {
+            effect.dispose();
+            section.effects.delete(key);
+          }
         }
+    
+     */
+        this.sectorMeshes.updateVertexData(section, compacted);
     }
     static removeSector(data) {
         const sector = MeshRegister.sectors.remove(data);

package/Renderer/MeshRegister.d.ts

@@ -1,16 +1,16 @@
 import { type LocationData } from "../Math/index.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
-export type MeshRegisterDimensions = Map<string, Map<string, SectorMesh>>;
+export type MeshRegisterDimensions = Map<number, Map<string, SectorMesh>>;
 declare class Sectors {
     static add(location: LocationData): SectorMesh;
     static remove(location: LocationData): false | SectorMesh;
     static get(location: LocationData): false | SectorMesh | undefined;
 }
 declare class Dimensions {
-    static add(id: string): Map<any, any>;
-    static get(id: string): Map<string, SectorMesh> | undefined;
-    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: any]>;
-    static remove(id: string): boolean;
+    static add(id: number): Map<any, any>;
+    static get(id: number): Map<string, SectorMesh> | undefined;
+    static getAllMeshes(id: number): Generator<[location: LocationData, substance: string, mesh: any]>;
+    static remove(id: number): boolean;
 }
 export declare class MeshRegister {
     static _dimensions: MeshRegisterDimensions;