@divinevoxel/vlox 0.0.3 → 0.0.5

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/DVESectionMeshInterface.d.ts

@@ -0,0 +1,3 @@
+export interface DVESectionMeshInterface {
+    dispose(): void;
+}

package/Renderer/Classes/DVESectionMeshes.d.ts

@@ -0,0 +1,6 @@
+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;
+}

package/Renderer/Classes/DVESectionMeshes.js

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

package/Renderer/Classes/SectionMesh.d.ts

@@ -0,0 +1,13 @@
+import { DVESectionMeshInterface } from "./DVESectionMeshInterface";
+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, DVESectionMeshInterface>;
+    effects: Map<string, VoxelEffect>;
+    constructor(sector: SectorMesh, index: number);
+    getPosition(): Vec3Array;
+    dispose(): void;
+}

package/Renderer/Classes/SectionMesh.js

@@ -0,0 +1,26 @@
+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();
+        }
+        for (const [key, mesh] of this.meshes) {
+            mesh.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,19 @@
+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) => MeshManager.updateSection(data));
+    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,54 @@
 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();
         }
     }
 }

package/Renderer/MeshRegister.d.ts

@@ -1,39 +1,26 @@
 import { type LocationData } from "../Math/index.js";
-import { MushRegisterRegion } from "./Classes/MushRegisterRegion.js";
-import { MeshRegisterColumn } from "./Classes/MeshRegisterColumn.js";
-import { ChunkMesh } from "./Classes/ChunkMesh.js";
-import { ChunkMeshInterface } from "./DVEChunkMeshInterface.js";
-export type MeshRegisterDimensions = Map<string, Map<string, MushRegisterRegion>>;
-declare class Chunk {
-    static addMesh(location: LocationData, mesh: ChunkMeshInterface, substance: string): ChunkMesh;
-    static add(location: LocationData): ChunkMesh;
-    static removeMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
-    static getMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
-    static remove(location: LocationData): false | ChunkMesh;
-    static get(location: LocationData): false | ChunkMesh;
-}
-declare class Column {
-    static add(location: LocationData): MeshRegisterColumn;
-    static remove(location: LocationData): false | MeshRegisterColumn;
-    static get(location: LocationData): false | MeshRegisterColumn | undefined;
-}
-declare class Region {
-    static add(location: LocationData): MushRegisterRegion;
-    static remove(location: LocationData): boolean;
-    static get(location: LocationData): false | MushRegisterRegion;
+import { SectorMesh } from "./Classes/SectorMesh.js";
+import { DVESectionMeshInterface } from "./Classes/DVESectionMeshInterface.js";
+export type MeshRegisterDimensions = Map<string, 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, MushRegisterRegion> | undefined;
-    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: ChunkMeshInterface]>;
+    static get(id: string): Map<string, SectorMesh> | undefined;
+    static getAllMeshes(id: string): Generator<[
+        location: LocationData,
+        substance: string,
+        mesh: DVESectionMeshInterface
+    ]>;
     static remove(id: string): boolean;
 }
 export declare class MeshRegister {
     static _dimensions: MeshRegisterDimensions;
     static dimensions: typeof Dimensions;
-    static region: typeof Region;
-    static column: typeof Column;
-    static chunk: typeof Chunk;
+    static sectors: typeof Sectors;
     static clearAll(): void;
 }
 export {};

package/Renderer/MeshRegister.js

@@ -1,155 +1,36 @@
-import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../Data/World/WorldSpaces.js";
-import { MushRegisterRegion } from "./Classes/MushRegisterRegion.js";
-import { MeshRegisterColumn } from "./Classes/MeshRegisterColumn.js";
-import { ChunkMesh } from "./Classes/ChunkMesh.js";
-class Chunk {
-    static addMesh(location, mesh, substance) {
-        let column = MeshRegister.column.get(location);
-        if (!column) {
-            column = MeshRegister.column.add(location);
-        }
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        let chunk = column.chunks.get(index);
-        if (!chunk) {
-            chunk = new ChunkMesh([location[1], location[2], location[3]]);
-            column.chunks.set(index, chunk);
-        }
-        chunk?.meshes.set(substance, mesh);
-        return chunk;
-    }
-    static add(location) {
-        let column = MeshRegister.column.get(location);
-        if (!column) {
-            column = MeshRegister.column.add(location);
-        }
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        let chunk = column.chunks.get(index);
-        if (!chunk) {
-            chunk = new ChunkMesh([location[1], location[2], location[3]]);
-            column.chunks.set(index, chunk);
-        }
-        return chunk;
-    }
-    static removeMesh(location, substance) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        const chunk = column.chunks.get(index);
-        if (!chunk)
-            return false;
-        const chunkMesh = chunk.meshes.get(substance);
-        if (!chunkMesh)
-            return false;
-        chunk.meshes.delete(substance);
-        if (chunk.meshes.size == 0) {
-            column.chunks.delete(index);
-        }
-        return chunkMesh;
-    }
-    static getMesh(location, substance) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
-        if (!chunk)
-            return false;
-        const chunkMesh = chunk.meshes.get(substance);
-        if (!chunkMesh)
-            return false;
-        return chunkMesh;
-    }
-    static remove(location) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        const chunk = column.chunks.get(index);
-        if (!chunk)
-            return false;
-        column.chunks.delete(index);
-        return chunk;
-    }
-    static get(location) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
-        if (!chunk)
-            return false;
-        return chunk;
-    }
-}
-class Column {
+import { WorldSpaces } from "../World/WorldSpaces.js";
+import { SectorMesh } from "./Classes/SectorMesh.js";
+class Sectors {
     static add(location) {
-        let region = MeshRegister.region.get(location);
-        if (!region) {
-            region = MeshRegister.region.add(location);
-        }
-        const column = new MeshRegisterColumn([
+        let dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension)
+            dimension = MeshRegister.dimensions.add(location[0]);
+        const sector = new SectorMesh([
             location[0],
-            ...Vector3Like.ToArray(WorldSpaces.column.getPositionXYZ(location[1], location[2], location[3])),
+            ...WorldSpaces.sector.getPositionVec3Array(location[1], location[2], location[3]),
         ]);
-        region.columns.set(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]), column);
-        return column;
+        dimension.set(WorldSpaces.hash.hashXYZ(location[1], location[2], location[3]), sector);
+        return sector;
     }
     static remove(location) {
-        const region = MeshRegister.region.get(location);
-        if (!region)
+        let dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension)
             return false;
-        const index = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
-        const column = region.columns.get(index);
-        if (!column)
+        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3]));
+        const sector = dimension.get(key);
+        if (!sector)
             return false;
-        region.columns.delete(index);
-        if (region.columns.size == 0) {
-            MeshRegister.region.remove(location);
+        dimension.delete(key);
+        if (dimension.size == 0) {
+            MeshRegister.dimensions.remove(location[0]);
         }
-        return column;
+        return sector;
     }
     static get(location) {
-        const region = MeshRegister.region.get(location);
-        if (!region)
-            return false;
-        return region.columns.get(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]));
-    }
-}
-class Region {
-    static add(location) {
         let dimension = MeshRegister.dimensions.get(location[0]);
-        if (!dimension) {
-            dimension = MeshRegister.dimensions.add(location[0]);
-        }
-        const region = new MushRegisterRegion();
-        dimension.set(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), region);
-        return region;
-    }
-    static remove(location) {
-        const region = this.get(location);
-        if (!region)
-            return false;
-        const dimension = MeshRegister.dimensions.get(location[0]);
-        if (!dimension)
-            return false;
-        dimension.delete(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
-        region.columns.forEach((column) => {
-            column.chunks.forEach((chunk) => {
-                chunk.meshes.forEach((chunkMeshes) => {
-                    chunkMeshes.dispose();
-                });
-            });
-        });
-        return true;
-    }
-    static get(location) {
-        const dimension = MeshRegister.dimensions.get(location[0]);
         if (!dimension)
             return false;
-        const region = dimension.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
-        if (!region)
-            return false;
-        return region;
+        return dimension.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3])));
     }
 }
 class Dimensions {
@@ -165,21 +46,19 @@ class Dimensions {
         const dimension = MeshRegister._dimensions.get(id);
         if (!dimension)
             return;
-        for (const [key, region] of dimension) {
-            for (const [columnKey, column] of region.columns) {
-                for (const [chunkKey, chunk] of column.chunks) {
-                    for (const [substance, mesh] of chunk.meshes) {
-                        yield [
-                            [
-                                column.location[0],
-                                column.location[1],
-                                column.location[2] + chunkKey * WorldSpaces.chunk._bounds.y,
-                                column.location[3],
-                            ],
-                            substance,
-                            mesh,
-                        ];
-                    }
+        for (const [key, sector] of dimension) {
+            for (let i = 0; i < sector.sections.length; i++) {
+                for (const [substance, mesh] of sector.sections[i].meshes) {
+                    yield [
+                        [
+                            sector.location[0],
+                            sector.location[1],
+                            sector.location[2] + i * WorldSpaces.section.bounds.y,
+                            sector.location[3],
+                        ],
+                        substance,
+                        mesh,
+                    ];
                 }
             }
         }
@@ -188,12 +67,10 @@ class Dimensions {
         const dimension = MeshRegister._dimensions.get(id);
         if (!dimension)
             return false;
-        dimension.forEach((region) => {
-            region.columns.forEach((column) => {
-                column.chunks.forEach((chunk) => {
-                    chunk.meshes.forEach((chunkMeshes) => {
-                        chunkMeshes.dispose();
-                    });
+        dimension.forEach((sector) => {
+            sector.sections.forEach((section) => {
+                section.meshes.forEach((sectionMeshes) => {
+                    sectionMeshes.dispose();
                 });
             });
         });
@@ -202,12 +79,9 @@ class Dimensions {
     }
 }
 export class MeshRegister {
-    // Main dimensions data store
     static _dimensions = new Map([["main", new Map()]]);
     static dimensions = Dimensions;
-    static region = Region;
-    static column = Column;
-    static chunk = Chunk;
+    static sectors = Sectors;
     static clearAll() {
         for (const [dkey, dim] of this._dimensions) {
             this.dimensions.remove(dkey);

package/Renderer/Renderer.types.d.ts

@@ -0,0 +1,21 @@
+import { CompactMeshData } from "../Mesher/Types/Mesher.types";
+import type { LocationData } from "../Math/index";
+export type SetSectionMeshTask = [
+    location: LocationData,
+    meshes: CompactMeshData,
+    effects: SectionEffectData[],
+    priority: number
+];
+export type SectionEffectData = [id: string, data: any];
+export type SectionMeshData = [
+    substanceType: string,
+    meshData: [location: LocationData, mesh: CompactMeshData]
+];
+export type RemoveSectionMeshTasks = [
+    location: LocationData,
+    substanceType: string
+];
+export type RemoveSectionsOutsideDistance = [
+    location: LocationData,
+    distance: number
+];

package/Renderer/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Classes/DVESectionMeshes";
+export * from "./Classes/DVESectionMeshInterface";
+export * from "./Classes/SectionMesh";
+export * from "./Classes/SectorMesh";

package/Renderer/index.js

@@ -0,0 +1,4 @@
+export * from "./Classes/DVESectionMeshes";
+export * from "./Classes/DVESectionMeshInterface";
+export * from "./Classes/SectionMesh";
+export * from "./Classes/SectorMesh";