@divinevoxel/vlox 0.0.4 → 0.0.6

package/Models/Input/BoxVoxelGometryInputs.d.ts

@@ -1,11 +1,12 @@
-import { QuadUVData } from "@amodx/meshing/Geometry.types";
+import { QuadUVData } from "../../Mesher/Geomtry/Geometry.types";
 export type BoxFaceArags = [
     enabled: boolean,
     Fliped: boolean,
     texture: number,
     rotation: number,
     transparent: boolean,
-    uvs: QuadUVData
+    uvs: QuadUVData,
+    index: number
 ];
 declare enum ArgIndexes {
     Enabled = 0,
@@ -13,7 +14,8 @@ declare enum ArgIndexes {
     Texture = 2,
     Rotation = 3,
     Transparent = 4,
-    UVs = 5
+    UVs = 5,
+    Index = 6
 }
 export type BoxVoxelGometryArgs = BoxFaceArags[];
 export declare class BoxVoxelGometryInputs {

package/Models/Input/BoxVoxelGometryInputs.js

@@ -1,4 +1,3 @@
-import { VoxelFacesArray } from "../../Math";
 var ArgIndexes;
 (function (ArgIndexes) {
     ArgIndexes[ArgIndexes["Enabled"] = 0] = "Enabled";
@@ -7,8 +6,9 @@ var ArgIndexes;
     ArgIndexes[ArgIndexes["Rotation"] = 3] = "Rotation";
     ArgIndexes[ArgIndexes["Transparent"] = 4] = "Transparent";
     ArgIndexes[ArgIndexes["UVs"] = 5] = "UVs";
+    ArgIndexes[ArgIndexes["Index"] = 6] = "Index";
 })(ArgIndexes || (ArgIndexes = {}));
-const getArgs = () => {
+const getArgs = (face) => {
     const args = [];
     args[ArgIndexes.Enabled] = true;
     args[ArgIndexes.Fliped] = false;
@@ -21,15 +21,15 @@ const getArgs = () => {
         [0, 0],
         [1, 0],
     ];
+    args[ArgIndexes.Index] = face;
     return args;
 };
 export class BoxVoxelGometryInputs {
     static ArgIndexes = ArgIndexes;
     static CreateArgs() {
         const base = [];
-        for (let i = 0; i < VoxelFacesArray.length; i++) {
-            const face = VoxelFacesArray[i];
-            base[face] = getArgs();
+        for (let face = 0; face < 6; face++) {
+            base[face] = getArgs(face);
         }
         return base;
     }

package/Models/Input/QuadVoxelGometryInputs.d.ts

@@ -1,4 +1,4 @@
-import { QuadUVData } from "@amodx/meshing/Geometry.types";
+import { QuadUVData } from "../../Mesher/Geomtry/Geometry.types";
 export type QuadVoxelGometryArgs = [
     enabled: boolean,
     fliped: boolean,

package/Models/Rules/Classes/OcclusionFace.js

@@ -1,5 +1,5 @@
 import { Vector3Like } from "@amodx/math";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { Quad } from "../../../Mesher/Geomtry/Primitives/Quad";
 export class OcclusionFace {
     parentId;
     nodeId;

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

@@ -1,15 +1,15 @@
 import { OcclusionFaceContainer } from "./OcclusionFace";
 import { BuildGeomtryInputs } from "../Functions/BuildGeomtryInputs";
 import { BuildStateData } from "../../../Voxels/Functions/BuildStateData";
-import { PrcoessedVoxelGeometryData } from "../../../Voxels/VoxelSyncData";
+import { CompiledVoxelGeometryData } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 export declare class VoxelRuleGeometry {
     id: string;
-    data: PrcoessedVoxelGeometryData;
+    data: CompiledVoxelGeometryData;
     occlusionPlane: OcclusionFaceContainer;
     inputs: ReturnType<typeof BuildGeomtryInputs>;
     faceCount: number;
     vertexCount: number;
     state: ReturnType<typeof BuildStateData>;
-    constructor(id: string, data: PrcoessedVoxelGeometryData, occlusionPlane?: OcclusionFaceContainer, inputs?: ReturnType<typeof BuildGeomtryInputs>);
+    constructor(id: string, data: CompiledVoxelGeometryData, occlusionPlane?: OcclusionFaceContainer, inputs?: ReturnType<typeof BuildGeomtryInputs>);
     clone(): VoxelRuleGeometry;
 }

package/Models/Rules/Functions/BuildGeomtryInputs.js

@@ -1,6 +1,5 @@
-import { Observable } from "@amodx/core/Observers";
 import { BoxVoxelGometryInputs } from "../../Input/BoxVoxelGometryInputs";
-import { VoxelFaceNameArray, VoxelFaceNameRecord } from "../../../Math";
+import { VoxelFaceNameArray } from "../../../Math";
 import { TextureManager } from "../../../Textures/TextureManager";
 import { Matrix2x2Like, AMath } from "@amodx/math";
 import { QuadVoxelGometryInputs } from "../../Input/QuadVoxelGometryInputs";
@@ -63,13 +62,13 @@ const mapQuadUvs = (uvs, rotation = 0, transform) => {
 };
 export function BuildGeomtryInputs(geomtry) {
     const inputObservers = new Map();
-    const getInputObserver = (id) => {
+    const onInput = (id, subscribe) => {
         let obs = inputObservers.get(id);
         if (!obs) {
-            obs = new Observable();
+            obs = [];
             inputObservers.set(id, obs);
         }
-        return obs;
+        return obs.push(subscribe);
     };
     let faceTransparentIndex = [];
     let faceCount = 0;
@@ -84,9 +83,8 @@ export function BuildGeomtryInputs(geomtry) {
                 const value = node.inputs[input];
                 if (isArgString(value)) {
                     args[argsIndex][input] = null;
-                    getInputObserver(value).subscribe((value) => {
+                    onInput(value, (value) => {
                         args[argsIndex][input] = value;
-                        console.warn("set the value", value, args[argsIndex][input]);
                     });
                 }
                 else {
@@ -95,69 +93,76 @@ export function BuildGeomtryInputs(geomtry) {
             }
         }
         if (node.type == "box") {
-            const newArgs = BoxVoxelGometryInputs.CreateArgs();
-            args.push(newArgs);
+            args.push(BoxVoxelGometryInputs.CreateArgs());
             const argsIndex = args.length - 1;
-            for (const face of VoxelFaceNameArray) {
+            for (let face = 0; face < 6; face++) {
                 const relativeFaceCount = faceCount;
-                const faceIndex = VoxelFaceNameRecord[face];
-                const faceData = node.faces[face];
+                const faceName = VoxelFaceNameArray[face];
+                const faceData = node.faces[faceName];
                 let defaultUvs = [0, 0, 1, 1];
                 if (isArgString(faceData.enabled)) {
-                    getInputObserver(String(faceData.enabled)).subscribe((value) => (args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Enabled] = value));
+                    onInput(String(faceData.enabled), (value) => (args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Enabled] =
+                        value));
                 }
                 if (isArgString(faceData.flip)) {
-                    getInputObserver(String(faceData.flip)).subscribe((value) => (args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Fliped] = value));
+                    onInput(String(faceData.flip), (value) => (args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Fliped] =
+                        value));
                 }
                 if (isArgString(faceData.transparent)) {
-                    getInputObserver(String(faceData.transparent)).subscribe((value) => {
-                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Transparent] = value;
-                        faceTransparentIndex[relativeFaceCount + faceIndex] =
-                            Boolean(value);
+                    onInput(String(faceData.transparent), (value) => {
+                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Transparent] = value;
+                        faceTransparentIndex[relativeFaceCount + face] = Boolean(value);
                     });
                 }
                 else {
-                    args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Transparent] = Boolean(faceData.transparent);
-                    faceTransparentIndex[relativeFaceCount + faceIndex] = Boolean(faceData.transparent);
+                    args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Transparent] =
+                        Boolean(faceData.transparent);
+                    faceTransparentIndex[relativeFaceCount + face] = Boolean(faceData.transparent);
                 }
                 if (isArgString(faceData.rotation)) {
-                    getInputObserver(String(faceData.rotation)).subscribe((value) => {
-                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation] = value;
-                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultUvs, value, tranform);
+                    onInput(String(faceData.rotation), (value) => {
+                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation] =
+                            value;
+                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.UVs] =
+                            mapQuadUvs(defaultUvs, value, tranform);
                     });
                 }
                 else {
                     faceData.rotation &&
-                        (args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation] = faceData.rotation);
+                        (args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation] =
+                            faceData.rotation);
                 }
                 if (isArgString(faceData.uv)) {
                     const defaultInput = geomtry.data.ogData.arguments[faceData.uv.substring(1)];
                     if (defaultInput.type == "box-uv" && defaultInput.default) {
-                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultInput.default, args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
+                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.UVs] =
+                            mapQuadUvs(defaultInput.default, args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
                         defaultUvs = defaultInput.default;
                     }
-                    getInputObserver(String(faceData.uv)).subscribe((value) => {
-                        args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(value, args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
+                    onInput(String(faceData.uv), (value) => {
+                        args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.UVs] =
+                            mapQuadUvs(value, args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
                     });
                 }
                 else {
-                    args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(faceData.uv, args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
+                    args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.UVs] =
+                        mapQuadUvs(faceData.uv, args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Rotation], tranform);
                     defaultUvs = faceData.uv;
                 }
                 if (isArgString(faceData.texture)) {
-                    getInputObserver(String(faceData.texture)).subscribe((value) => (args[argsIndex][VoxelFaceNameRecord[face]][BoxVoxelGometryInputs.ArgIndexes.Texture] = value));
+                    onInput(String(faceData.texture), (value) => (args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Texture] =
+                        value));
                 }
             }
             faceCount += 6;
         }
         if (node.type == "quad") {
-            const newArgs = QuadVoxelGometryInputs.CreateArgs();
-            args.push(newArgs);
+            args.push(QuadVoxelGometryInputs.CreateArgs());
             const argsIndex = args.length - 1;
             const relativeFaceCount = faceCount;
             let defaultUvs = [0, 0, 1, 1];
             if (isArgString(node.transparent)) {
-                getInputObserver(String(node.transparent)).subscribe((value) => {
+                onInput(String(node.transparent), (value) => {
                     args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Transparent] =
                         value;
                     faceTransparentIndex[relativeFaceCount] = Boolean(value);
@@ -169,7 +174,7 @@ export function BuildGeomtryInputs(geomtry) {
                 faceTransparentIndex[relativeFaceCount] = Boolean(node.transparent);
             }
             if (isArgString(node.doubleSided)) {
-                getInputObserver(String(node.doubleSided)).subscribe((value) => {
+                onInput(String(node.doubleSided), (value) => {
                     args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.DoubleSided] =
                         value;
                 });
@@ -179,7 +184,7 @@ export function BuildGeomtryInputs(geomtry) {
                     Boolean(node.doubleSided);
             }
             if (isArgString(node.textureRotation)) {
-                getInputObserver(String(node.textureRotation)).subscribe((value) => {
+                onInput(String(node.textureRotation), (value) => {
                     args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation] = value;
                     args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultUvs, value, tranform);
                 });
@@ -195,7 +200,7 @@ export function BuildGeomtryInputs(geomtry) {
                     args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultInput.default, args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation], tranform);
                     defaultUvs = defaultInput.default;
                 }
-                getInputObserver(String(node.uv)).subscribe((value) => {
+                onInput(String(node.uv), (value) => {
                     args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(value, args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation], tranform);
                 });
             }
@@ -204,7 +209,7 @@ export function BuildGeomtryInputs(geomtry) {
                 defaultUvs = node.uv;
             }
             if (isArgString(node.texture)) {
-                getInputObserver(String(node.texture)).subscribe((value) => (args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Texture] = value));
+                onInput(String(node.texture), (value) => (args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Texture] = value));
             }
             faceCount++;
         }
@@ -233,7 +238,9 @@ export function BuildGeomtryInputs(geomtry) {
                 if (data.type == "texture") {
                     value = TextureManager.getTextureIndex(value);
                 }
-                obs.notify(value);
+                for (const func of obs) {
+                    func(value);
+                }
             },
         });
     }

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

@@ -1,4 +1,4 @@
 import { OcclusionFaceContainer } from "../Classes/OcclusionFace";
 import { VoxelRuleGeometry } from "../Classes/VoxelRulesGeometry";
-import { PrcoessedVoxelGeometryNodes } from "../../../Voxels/VoxelSyncData";
-export declare function GetOcclusionFaces(parentId: string, geometry: VoxelRuleGeometry, data: PrcoessedVoxelGeometryNodes[]): OcclusionFaceContainer;
+import { CompiledVoxelGeometryNodes } from "../../../Voxels/Types/VoxelModelCompiledData.types";
+export declare function GetOcclusionFaces(parentId: string, geometry: VoxelRuleGeometry, data: CompiledVoxelGeometryNodes[]): OcclusionFaceContainer;

package/Models/Rules/Functions/GetOcclusionFaces.js

@@ -2,7 +2,7 @@ import { Vector3Like } from "@amodx/math";
 import { OcclusionFlatQuadFace, OcclusionFaceContainer, OcclusionQuadFace, } from "../Classes/OcclusionFace";
 import { VoxelFaces } from "../../../Math";
 import { TransformBox, TransformQuad } from "../../Shared/Transform";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { Quad } from "../../../Mesher/Geomtry/Primitives/Quad";
 export function GetOcclusionFaces(parentId, geometry, data) {
     const faceContainer = new OcclusionFaceContainer();
     let vertexCount = 0;

package/Models/Shared/Transform.d.ts

@@ -1,4 +1,4 @@
-import { Quad } from "@amodx/meshing/Primitives/Quad";
-import { VoxelGeometryTransform } from "../../Voxels/VoxelSyncData";
+import { Quad } from "../../Mesher/Geomtry/Primitives/Quad";
+import { VoxelGeometryTransform } from "../../Voxels/Types/VoxelModelCompiledData.types";
 export declare function TransformQuad(quad: Quad, transform: VoxelGeometryTransform): Quad;
 export declare function TransformBox(quads: [Quad, Quad, Quad, Quad, Quad, Quad], transform: VoxelGeometryTransform): [Quad, Quad, Quad, Quad, Quad, Quad];

package/Models/Shared/Transform.js

@@ -1,5 +1,5 @@
-import { Quad } from "@amodx/meshing/Primitives/Quad";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { Quad } from "../../Mesher/Geomtry/Primitives/Quad";
+import { QuadVerticies } from "../../Mesher/Geomtry/Geometry.types";
 import { Vector3Like } from "@amodx/math";
 // Utility function to convert degrees to radians
 function degreesToRadians(degrees) {
@@ -238,7 +238,6 @@ export function TransformBox(quads, transform) {
         }
     }
     // Update the quads with transformed vertices
-    const transformedQuads = [];
     for (const quad of quads) {
         const originalVertices = [
             quad.positions.vertices[QuadVerticies.TopRight],
@@ -254,8 +253,7 @@ export function TransformBox(quads, transform) {
         if (determinant < 0) {
             transformedVertices.reverse();
         }
-        const newQuad = Quad.Create(transformedVertices.map((v) => Vector3Like.ToArray(v)));
-        transformedQuads.push(newQuad);
+        quad.setPositions(transformedVertices.map((v) => Vector3Like.ToArray(v)));
     }
-    return transformedQuads;
+    return quads;
 }

package/Models/VoxelModel.types.d.ts

@@ -1,5 +1,5 @@
 import { Vec2Array, Vec3Array } from "@amodx/math";
-import { QuadUVData } from "@amodx/meshing/Geometry.types";
+import { QuadUVData } from "../Mesher/Geomtry/Geometry.types";
 import { VoxelFaceNames } from "../Math";
 import { VoxelStateStringSchemaData, VoxelModelRelationsSchemaData, VoxelStateNumberSchemaData } from "../Voxels/State/State.types";
 import { VoxelEffectData } from "../Voxels/Effects/VoxelEffects.types";

package/Renderer/Classes/DVESectionMeshes.d.ts

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

package/Renderer/Classes/DVESectionMeshes.js

@@ -0,0 +1,2 @@
+export class DVESectionMeshes {
+}

package/Renderer/Classes/SectionMesh.d.ts

@@ -0,0 +1,12 @@
+import { VoxelEffect } from "../../Voxels/Effects/VoxelEffect";
+import { SectorMesh } from "./SectorMesh";
+import { Vec3Array } from "@amodx/math";
+export declare class SectionMesh {
+    sector: SectorMesh;
+    index: number;
+    meshes: Map<string, any>;
+    effects: Map<string, VoxelEffect>;
+    constructor(sector: SectorMesh, index: number);
+    getPosition(): Vec3Array;
+    dispose(): void;
+}

package/Renderer/Classes/SectionMesh.js

@@ -0,0 +1,23 @@
+import { WorldSpaces } from "../../World/WorldSpaces";
+export class SectionMesh {
+    sector;
+    index;
+    meshes = new Map();
+    effects = new Map();
+    constructor(sector, index) {
+        this.sector = sector;
+        this.index = index;
+    }
+    getPosition() {
+        return [
+            this.sector.location[1],
+            this.sector.location[1] + WorldSpaces.section.bounds.y * this.index,
+            this.sector.location[2],
+        ];
+    }
+    dispose() {
+        for (const [key, effect] of this.effects) {
+            effect.dispose();
+        }
+    }
+}

package/Renderer/Classes/SectorMesh.d.ts

@@ -0,0 +1,11 @@
+import { LocationData } from "../../Math";
+import { SectionMesh } from "./SectionMesh";
+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;
+}

package/Renderer/Classes/SectorMesh.js

@@ -0,0 +1,33 @@
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { SectionMesh } from "./SectionMesh";
+export class SectorMesh {
+    location;
+    sections = [];
+    constructor(location) {
+        this.location = location;
+    }
+    getIndex(y) {
+        const ry = y - this.location[2];
+        const index = ry / WorldSpaces.section.bounds.y;
+        return index;
+    }
+    getSection(y) {
+        return this.sections[this.getIndex(y)];
+    }
+    addSection(y) {
+        const index = this.getIndex(y);
+        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);
+        if (!this.sections[index])
+            return false;
+        const section = this.sections[index];
+        delete this.sections[index];
+        return section;
+    }
+}

package/Renderer/DVERenderNode.types.d.ts

@@ -1,6 +1,6 @@
 import type { Vec3Array } from "@amodx/math";
 import type { TypedArrays } from "@amodx/binary/";
-export type DVEChunkMeshesAttributes = [
+export type DVESectionMeshesAttributes = [
     id: string,
     data: TypedArrays,
     stride: number,

package/Renderer/DVERenderer.d.ts

@@ -1,6 +1,6 @@
 import { DivineVoxelEngineRender } from "Contexts/Render";
-import { DVEChunkMeshes } from "./DVEChunkMeshes";
+import { DVESectionMeshes } from "./Classes/DVESectionMeshes";
 export declare abstract class DVERenderer {
-    abstract chunkMeshes: DVEChunkMeshes;
+    abstract sectorMeshes: DVESectionMeshes;
     abstract init(dver: DivineVoxelEngineRender): Promise<void>;
 }

package/Renderer/InitTasks.d.ts

@@ -0,0 +1,2 @@
+import { Thread, ThreadPool } from "@amodx/threads/";
+export default function RendererTasks(threads: Thread | ThreadPool): void;

package/Renderer/InitTasks.js

@@ -0,0 +1,31 @@
+import { Threads } from "@amodx/threads/";
+import { MeshManager } from "./MeshManager";
+import { MeshRegister } from "./MeshRegister";
+import { TaskTool } from "../Tools/Tasks/TasksTool";
+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]);
+            }
+        }
+        origin.sendMessage(data, tranfers);
+    });
+    Threads.registerTask("remove-sector", (data) => {
+        MeshManager.removeSector(data);
+    });
+    Threads.registerTask("clear-all", (data) => {
+        MeshRegister.clearAll();
+    });
+    Threads.registerTask("build-queue", ([dim, sections]) => {
+        for (const position of sections) {
+            tasks.build.section.run([dim, ...position]);
+        }
+    });
+}

package/Renderer/MeshManager.d.ts

@@ -1,11 +1,9 @@
-import { RemoveChunkMeshTasks, SetChunkMeshTask } from "../Contexts/Render/Tasks/RenderTasks.types.js";
+import { SetSectionMeshTask } from "../Renderer/Renderer.types";
 import { LocationData } from "../Math/index.js";
+import { DVESectionMeshes } from "./Classes/DVESectionMeshes";
 export declare class MeshManager {
+    static sectorMeshes: DVESectionMeshes;
     static runningUpdate: boolean;
-    private static columnSquare;
-    private static renderCircle;
-    static removeColumnsOutsideRadius(origion: LocationData, radius: number): void;
-    static remove(data: RemoveChunkMeshTasks): false | undefined;
-    static update(data: SetChunkMeshTask): void;
-    static removeColumn(data: LocationData): false | undefined;
+    static updateSection(data: SetSectionMeshTask): void;
+    static removeSector(data: LocationData): false | undefined;
 }

package/Renderer/MeshManager.js

@@ -1,79 +1,58 @@
 import { MeshRegister } from "./MeshRegister.js";
-import { DivineVoxelEngineRender } from "../Contexts/Render/DivineVoxelEngineRender.js";
-import { Square, Circle } from "@amodx/math/Shapes";
-import { Vector2Like } from "@amodx/math";
-import { WorldSpaces } from "../Data/World/WorldSpaces.js";
 import { VoxelEffectRegister } from "../Voxels/Effects/VoxelEffectRegister.js";
 const added = new Set();
 export class MeshManager {
+    static sectorMeshes;
     static runningUpdate = false;
-    static columnSquare = new Square(Vector2Like.Create(1, 1), 16);
-    static renderCircle = new Circle(Vector2Like.Create(0.1, 1), 10);
-    static removeColumnsOutsideRadius(origion, radius) {
-        const [dimesnionId, x, y, z] = origion;
-        const dimension = MeshRegister.dimensions.get(dimesnionId);
-        if (!dimension)
-            return;
-        this.columnSquare.sideLength = WorldSpaces.column._bounds.x;
-        this.renderCircle.radius = radius;
-        this.renderCircle.center.x = origion[1];
-        this.renderCircle.center.y = origion[3];
-        dimension.forEach((region) => {
-            region.columns.forEach((column) => {
-                const location = column.location;
-                this.columnSquare.center.x = location[1];
-                this.columnSquare.center.y = location[3];
-                if (!Circle.IsSquareInsideOrTouchingCircle(this.columnSquare, this.renderCircle)) {
-                    this.removeColumn(location);
-                }
-            });
-        });
-    }
-    static remove(data) {
-        const [location, substance] = data;
-        const mesh = MeshRegister.chunk.removeMesh(location, substance);
-        if (!mesh)
-            return false;
-        mesh.dispose();
-    }
-    static update(data) {
-        const [location, chunks, effects] = data;
-        let i = chunks.length;
-        let chunk = MeshRegister.chunk.get(location);
-        if (!chunk) {
-            chunk = MeshRegister.chunk.add(location);
+    static updateSection(data) {
+        const location = data[0];
+        const sections = data[1];
+        const effects = data[2];
+        let sector = MeshRegister.sectors.get(location);
+        if (!sector) {
+            sector = MeshRegister.sectors.add(location);
+        }
+        let section = sector.getSection(location[2]);
+        if (!section) {
+            section = sector.addSection(location[2]);
         }
         added.clear();
         for (const [id, points] of effects) {
             added.add(id);
-            if (!chunk.effects.has(id)) {
+            if (!section.effects.has(id)) {
                 const EffectClass = VoxelEffectRegister.get(id);
-                const newEffect = new EffectClass(chunk);
+                const newEffect = new EffectClass(section);
                 newEffect.init();
                 newEffect.setPoints(points);
-                chunk.effects.set(id, newEffect);
+                section.effects.set(id, newEffect);
             }
             else {
-                const effect = chunk.effects.get(id);
+                const effect = section.effects.get(id);
                 effect.setPoints(points);
             }
         }
-        for (const [key, effect] of chunk.effects) {
+        for (const [key, effect] of section.effects) {
             if (!added.has(key)) {
                 effect.dispose();
-                chunk.effects.delete(key);
+                section.effects.delete(key);
             }
         }
-        if (data[1][0] == 0) {
-            DivineVoxelEngineRender.instance.renderer.chunkMeshes.updateVertexData(chunk, [location[1], location[2], location[3]], data[1]);
+        if (sections[0] == 0) {
+            this.sectorMeshes.updateVertexData(section, [location[1], location[2], location[3]], sections);
         }
     }
-    static removeColumn(data) {
-        const column = MeshRegister.column.remove(data);
-        if (!column)
+    static removeSector(data) {
+        const sector = MeshRegister.sectors.remove(data);
+        if (!sector)
             return false;
-        for (const [key, chunk] of column.chunks) {
-            chunk.dispose();
+        for (const section of sector.sections) {
+            if (!section)
+                continue;
+            section.dispose();
+            for (const [, mesh] of section.meshes) {
+                this.sectorMeshes.returnMesh(mesh);
+            }
+            section.meshes.clear();
         }
     }
 }