@divinevoxel/vlox 0.0.74 → 0.0.75

package/Math/CardinalNeighbors.js

@@ -1,5 +1,19 @@
-export const $3dMooreNeighborhood = [];
-export const $2dMooreNeighborhood = [
+/**
+ * A read-only array of 2D coordinates (x, y) representing
+ * the Moore neighborhood in 2D. This neighborhood includes
+ * the cell itself (0,0) as well as the eight surrounding cells.
+ *
+ * Each tuple `[dx, dy]` is an offset from the center cell.
+ *
+ * Example offsets include:
+ * - (0, 0)   - the cell itself
+ * - (1, 0)   - one step to the right
+ * - (0, 1)   - one step down
+ * - (1, 1)   - diagonal down-right
+ * - (-1, 0)  - one step to the left
+ * - etc.
+ */
+export const MooreNeighborhood2D = [
     [0, 0],
     [1, 0],
     [0, 1],
@@ -10,7 +24,30 @@ export const $2dMooreNeighborhood = [
     [1, -1],
     [-1, 1],
 ];
-export const $3dCardinalNeighbors = [
+const array3d = [];
+for (let y = -1; y < 2; y++) {
+    for (const n of MooreNeighborhood2D) {
+        array3d.push([n[0], y, n[1]]);
+    }
+}
+/**
+ * A read-only array of 3D coordinates (x, y, z) representing
+ * the Moore neighborhood in 3D. This includes the cell itself
+ * plus all adjacent cells within a 1-unit Chebyshev distance
+ * in a 3D grid.
+ *
+ * Each tuple `[dx, dy, dz]` is an offset from the center cell.
+ */
+export const MooreNeighborhood3D = array3d;
+/**
+ * A read-only array of 3D coordinates (x, y, z) representing
+ * the six cardinal (orthogonal) directions in a 3D grid. These
+ * do not include the center cell. Typically used for direct
+ * neighbors up/down, left/right, forward/backward.
+ *
+ * Each tuple `[dx, dy, dz]` is an offset from the center cell.
+ */
+export const CardinalNeighbors3D = [
     [0, 1, 0],
     [0, -1, 0],
     [1, 0, 0],
@@ -18,8 +55,17 @@ export const $3dCardinalNeighbors = [
     [0, 0, -1],
     [0, 0, 1],
 ];
-for (let y = -1; y < 2; y++) {
-    for (const n of $2dMooreNeighborhood) {
-        $3dMooreNeighborhood.push([n[0], y, n[1]]);
-    }
-}
+/**
+* A read-only array of 2D coordinates (x, y) representing
+* the six cardinal (orthogonal) directions in a 2D grid. These
+* do not include the center cell. Typically used for direct
+* neighbors up/down, left/right
+*
+* Each tuple `[dx, dy]` is an offset from the center cell.
+*/
+export const CardinalNeighbors2D = [
+    [0, 1],
+    [0, -1],
+    [1, 0],
+    [-1, 0],
+];

package/Math/Indexing.d.ts

@@ -1,4 +1,5 @@
 import { Vec3Array, Vector3Like } from "@amodx/math";
+export type IndexOrderingTypes = "XYZ" | "XZY" | "YXZ";
 export declare function CubeHashVec3Array(positionX: number, positionY: number, positionZ: number, xPower2: number, yPower2: number, zPower2: number, positionRef?: Vec3Array): Vec3Array;
 export declare function CubeHashVec3(positionX: number, positionY: number, positionZ: number, xPower2: number, yPower2: number, zPower2: number, positionRef?: Vector3Like): Vector3Like;
 /**

package/Math/Location.d.ts

@@ -0,0 +1,10 @@
+export type LocationData = [
+    /**Index for the dimension */
+    dimensionIndex: number,
+    /**x position */
+    x: number,
+    /**y position */
+    y: number,
+    /**z position */
+    z: number
+];

package/Math/UtilFunctions.d.ts

@@ -0,0 +1,4 @@
+import { Vec3Array, Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "./VoxelFaces";
+export declare function closestUnitNormal(v: Vec3Array | Vector3Like): Vec3Array;
+export declare function closestVoxelFace(v: Vec3Array | Vector3Like): VoxelFaces;

package/Math/UtilFunctions.js

@@ -0,0 +1,52 @@
+import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "./VoxelFaces";
+const unitNormals = [
+    [0, 1, 0],
+    [0, -1, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+    [1, 0, 0],
+    [-1, 0, 0],
+];
+const tempPosition = [0, 0, 0];
+const tempNormal = [0, 0, 0];
+export function closestUnitNormal(v) {
+    const [x, y, z] = Vector3Like.Deconstruct(v);
+    tempPosition[0] = x;
+    tempPosition[1] = y;
+    tempPosition[2] = z;
+    let closestIndex = -1;
+    let closestDistance = Infinity;
+    for (let i = 0; i < unitNormals.length; i++) {
+        Vec3ArrayLike.SubtractToRef(tempPosition, unitNormals[i], tempNormal);
+        const distance = Vec3ArrayLike.Length(tempNormal);
+        if (distance < closestDistance) {
+            closestDistance = distance;
+            closestIndex = i;
+        }
+    }
+    if (closestIndex == -1)
+        return [0, 0, 0];
+    return [
+        unitNormals[closestIndex][0],
+        unitNormals[closestIndex][1],
+        unitNormals[closestIndex][2],
+    ];
+}
+export function closestVoxelFace(v) {
+    const unitNormal = closestUnitNormal(v);
+    let closestFace = VoxelFaces.Up;
+    if (unitNormal[0] == 1)
+        closestFace = VoxelFaces.East;
+    if (unitNormal[0] == -1)
+        closestFace = VoxelFaces.West;
+    if (unitNormal[1] == 1)
+        closestFace = VoxelFaces.Up;
+    if (unitNormal[1] == -1)
+        closestFace = VoxelFaces.Down;
+    if (unitNormal[2] == 1)
+        closestFace = VoxelFaces.North;
+    if (unitNormal[2] == -1)
+        closestFace = VoxelFaces.South;
+    return closestFace;
+}

package/Math/index.d.ts

@@ -1,12 +1,3 @@
 export * from "./VoxelFaces.js";
 export * from "./VoxelFaces.js";
-export type LocationData = [
-    /**Index for the dimension */
-    dimensionIndex: number,
-    /**x position */
-    x: number,
-    /**y position */
-    y: number,
-    /**z position */
-    z: number
-];
+export * from "./Location.js";

package/Math/index.js

@@ -1,2 +1,3 @@
 export * from "./VoxelFaces.js";
 export * from "./VoxelFaces.js";
+export * from "./Location.js";

package/Mesher/Functions/Base/MeshSectionBase.d.ts

@@ -0,0 +1,5 @@
+import { LocationData } from "../../../Math";
+import type { SetSectionMeshTask } from "../../Types/Mesher.types";
+import { SectionCursor } from "../../../World/Cursor/SectionCursor.js";
+import { DataCursorInterface } from "Voxels/Cursor/DataCursor.interface";
+export declare function MeshSectionBase(worldCursor: DataCursorInterface, sectionCursor: SectionCursor, location: LocationData, transfers?: any[]): SetSectionMeshTask | null;

package/Mesher/Functions/Base/MeshSectionBase.js

@@ -0,0 +1,105 @@
+//data
+import { WorldSpaces } from "../../../World/WorldSpaces.js";
+//tools
+import { VoxelGeometryBuilderCacheSpace } from "../../Models/VoxelGeometryBuilderCacheSpace.js";
+import { VoxelModelConstructorRegister } from "../../Models/VoxelModelConstructorRegister.js";
+import { VoxelMeshBVHBuilder } from "../../Geomtry/VoxelMeshBVHBuilder";
+import { Vector3Like } from "@amodx/math";
+import { RenderedMaterials } from "../../Models/RenderedMaterials";
+import { CompactVoxelSectionMesh } from "../CompactVoxelSectionMesh";
+let space;
+const bvhTool = new VoxelMeshBVHBuilder();
+function meshVoxel(x, y, z, voxel, worldCursor, sectionCursor) {
+    let added = false;
+    const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getVoxelId()];
+    const builder = constructor.builder;
+    builder.origin.x = sectionCursor._voxelPosition.x;
+    builder.origin.y = sectionCursor._voxelPosition.y;
+    builder.origin.z = sectionCursor._voxelPosition.z;
+    builder.position.x = x;
+    builder.position.y = y;
+    builder.position.z = z;
+    builder.voxel = voxel;
+    builder.nVoxel = worldCursor;
+    builder.startConstruction();
+    added = constructor.process();
+    builder.endConstruction();
+    return added;
+}
+const padding = Vector3Like.Create(5, 5, 5);
+export function MeshSectionBase(worldCursor, sectionCursor, location, transfers = []) {
+    if (!space)
+        space = new VoxelGeometryBuilderCacheSpace({
+            x: WorldSpaces.section.bounds.x + padding.x,
+            y: WorldSpaces.section.bounds.y + padding.y,
+            z: WorldSpaces.section.bounds.z + padding.z,
+        });
+    const { x: cx, y: cy, z: cz } = sectionCursor._sectionPosition;
+    const section = sectionCursor._section;
+    let [minY, maxY] = section.getMinMax();
+    if (minY == Infinity && maxY == -Infinity) {
+        section.setInProgress(false);
+        return null;
+    }
+    space.start(cx - (padding.x - 1), cy - (padding.y - 1), cz - (padding.z - 1));
+    bvhTool.reset();
+    const effects = {};
+    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
+        const mesher = RenderedMaterials.meshers[i];
+        mesher.space = space;
+        mesher.bvhTool = bvhTool;
+        mesher.effects = effects;
+    }
+    const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
+    const startY = minY * slice;
+    const endY = (maxY + 1) * slice;
+    for (let i = startY; i < endY; i++) {
+        if (!(i % slice)) {
+            const y = i / slice;
+            if (!section.getHasVoxel(y) && !section.getHasVoxelDirty(y)) {
+                i += slice - 1;
+                continue;
+            }
+        }
+        if (!section.ids[i] || section.getBuried(i))
+            continue;
+        const voxel = sectionCursor.getVoxelAtIndex(i);
+        const x = cx + sectionCursor._voxelPosition.x;
+        const y = cy + sectionCursor._voxelPosition.y;
+        const z = cz + sectionCursor._voxelPosition.z;
+        let addedVoxel = false;
+        if (meshVoxel(x, y, z, voxel, worldCursor, sectionCursor))
+            addedVoxel = true;
+        if (voxel.hasSecondaryVoxel()) {
+            voxel.setSecondary(true);
+            if (meshVoxel(x, y, z, voxel, worldCursor, sectionCursor))
+                addedVoxel = true;
+            voxel.setSecondary(false);
+        }
+        section.setBuried(i, !addedVoxel);
+    }
+    const meshed = [];
+    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
+        const mesher = RenderedMaterials.meshers[i];
+        if (!mesher.mesh.vertexCount) {
+            mesher.clear();
+            mesher.bvhTool = null;
+            continue;
+        }
+        const { min, max } = mesher.bvhTool.getMeshBounds();
+        mesher.mesh.minBounds.x = min[0];
+        mesher.mesh.minBounds.y = min[1];
+        mesher.mesh.minBounds.z = min[2];
+        mesher.mesh.maxBounds.x = max[0];
+        mesher.mesh.maxBounds.y = max[1];
+        mesher.mesh.maxBounds.z = max[2];
+        meshed.push(mesher);
+    }
+    const compactMesh = CompactVoxelSectionMesh(location, meshed, transfers);
+    for (let i = 0; i < meshed.length; i++) {
+        meshed[i].clear();
+        meshed[i].bvhTool = null;
+    }
+    section.setInProgress(false);
+    return compactMesh;
+}

package/Mesher/Functions/CompactVoxelSectionMesh.js

@@ -20,9 +20,7 @@ export function CompactVoxelSectionMesh(location, tools, transfers = []) {
         // Align after writing vertex data
         totalByteCount = align4(totalByteCount);
         // Add the index data
-        const indexByteSize = tool.mesh.indicieCount > 65535
-            ? tool.mesh.indicieCount * 4
-            : tool.mesh.indicieCount * 2;
+        const indexByteSize = tool.mesh.indicieCount * 4;
         totalByteCount += indexByteSize;
         // Align after writing index data
         totalByteCount = align4(totalByteCount);
@@ -37,7 +35,7 @@ export function CompactVoxelSectionMesh(location, tools, transfers = []) {
     for (let i = 0; i < tools.length; i++) {
         const tool = tools[i];
         // Fill out the meshData structure
-        meshData.material = tool.id;
+        meshData.materialId = tool.id;
         const minBounds = tool.mesh.minBounds;
         const maxBounds = tool.mesh.maxBounds;
         meshData.minBounds[0] = minBounds.x;
@@ -58,9 +56,7 @@ export function CompactVoxelSectionMesh(location, tools, transfers = []) {
         // Index info
         meshData.indiceIndex[0] = byteCount;
         meshData.indiceIndex[1] = tool.mesh.indicieCount;
-        const indexByteCount = tool.mesh.indicieCount > 65535
-            ? tool.mesh.indicieCount * 4
-            : tool.mesh.indicieCount * 2;
+        const indexByteCount = tool.mesh.indicieCount * 4;
         byteCount += indexByteCount;
         // Align to 4 bytes for the next iteration (or final)
         byteCount = align4(byteCount);
@@ -85,9 +81,7 @@ export function CompactVoxelSectionMesh(location, tools, transfers = []) {
                 break;
         }
         // Write index data
-        const indicesArray = tool.mesh.indicieCount > 65535
-            ? new Uint32Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount)
-            : new Uint16Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount);
+        const indicesArray = new Uint32Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount);
         const indiceBuffers = tool.mesh.indices._buffers;
         start = 0;
         done = false;

package/Mesher/Functions/MeshSection.js

@@ -1,119 +1,15 @@
-//data
-import { WorldSpaces } from "../../World/WorldSpaces.js";
 //tools
-import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
 import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SectionCursor } from "../../World/Cursor/SectionCursor.js";
-import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
 import { WorldRegister } from "../../World/WorldRegister.js";
-import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
-import { Vector3Like } from "@amodx/math";
-import { RenderedMaterials } from "../Models/RenderedMaterials";
-import { CompactVoxelSectionMesh } from "./CompactVoxelSectionMesh";
+import { MeshSectionBase } from "./Base/MeshSectionBase";
 const sectionCursor = new SectionCursor();
 const worldCursor = new WorldCursor();
-let space;
-const bvhTool = new VoxelMeshBVHBuilder();
-function meshVoxel(x, y, z, voxel) {
-    let added = false;
-    const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getId()];
-    const builder = constructor.builder;
-    builder.origin.x = sectionCursor._voxelPosition.x;
-    builder.origin.y = sectionCursor._voxelPosition.y;
-    builder.origin.z = sectionCursor._voxelPosition.z;
-    builder.position.x = x;
-    builder.position.y = y;
-    builder.position.z = z;
-    builder.voxel = voxel;
-    builder.nVoxel = worldCursor;
-    builder.startConstruction();
-    added = constructor.process();
-    builder.endConstruction();
-    return added;
-}
-const padding = Vector3Like.Create(5, 5, 5);
 export function MeshSection(location, transfers = []) {
-    if (!space)
-        space = new VoxelGeometryBuilderCacheSpace({
-            x: WorldSpaces.section.bounds.x + padding.x,
-            y: WorldSpaces.section.bounds.y + padding.y,
-            z: WorldSpaces.section.bounds.z + padding.z,
-        });
     const sector = WorldRegister.sectors.getAt(location);
     if (!sector)
         return null;
-    const section = sector.getSection(location[1], location[2], location[3]);
-    const [cx, cy, cz] = section.getPosition();
     worldCursor.setFocalPoint(...location);
-    sectionCursor.setSection(...location);
-    let [minY, maxY] = section.getMinMax();
-    if (minY == Infinity && maxY == -Infinity) {
-        section.setDisplayDirty(false);
-        section.setInProgress(false);
-        return null;
-    }
-    space.start(cx - (padding.x - 1), cy - (padding.y - 1), cz - (padding.z - 1));
-    bvhTool.reset();
-    const effects = {};
-    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
-        const mesher = RenderedMaterials.meshers[i];
-        mesher.space = space;
-        mesher.bvhTool = bvhTool;
-        mesher.effects = effects;
-    }
-    const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
-    const startY = minY * slice;
-    const endY = (maxY + 1) * slice;
-    for (let i = startY; i < endY; i++) {
-        if (!(i % slice)) {
-            const y = i / slice;
-            if (!section.getHasVoxel(y) && !section.getHasVoxelDirty(y)) {
-                i += slice - 1;
-                continue;
-            }
-        }
-        if (!section.ids[i])
-            continue;
-        if (!section.ids[i] || section.getBuried(i))
-            continue;
-        const voxel = sectionCursor.getVoxelAtIndex(i);
-        const x = cx + sectionCursor._voxelPosition.x;
-        const y = cy + sectionCursor._voxelPosition.y;
-        const z = cz + sectionCursor._voxelPosition.z;
-        let addedVoxel = false;
-        if (meshVoxel(x, y, z, voxel))
-            addedVoxel = true;
-        if (voxel.hasSecondaryVoxel()) {
-            voxel.setSecondary(true);
-            if (meshVoxel(x, y, z, voxel))
-                addedVoxel = true;
-            voxel.setSecondary(false);
-        }
-        section.setBuried(i, !addedVoxel);
-    }
-    const meshed = [];
-    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
-        const mesher = RenderedMaterials.meshers[i];
-        if (!mesher.mesh.vertexCount) {
-            mesher.clear();
-            mesher.bvhTool = null;
-            continue;
-        }
-        const { min, max } = mesher.bvhTool.getMeshBounds();
-        mesher.mesh.minBounds.x = min[0];
-        mesher.mesh.minBounds.y = min[1];
-        mesher.mesh.minBounds.z = min[2];
-        mesher.mesh.maxBounds.x = max[0];
-        mesher.mesh.maxBounds.y = max[1];
-        mesher.mesh.maxBounds.z = max[2];
-        meshed.push(mesher);
-    }
-    const compactMesh = CompactVoxelSectionMesh(location, meshed, transfers);
-    for (let i = 0; i < meshed.length; i++) {
-        meshed[i].clear();
-        meshed[i].bvhTool = null;
-    }
-    section.setDisplayDirty(false);
-    section.setInProgress(false);
-    return compactMesh;
+    sectionCursor.loadSection(...location);
+    return MeshSectionBase(worldCursor, sectionCursor, location, transfers);
 }

package/Mesher/Functions/MeshSectionSnapShot.d.ts

@@ -0,0 +1,3 @@
+import type { SetSectionMeshTask } from "../Types/Mesher.types";
+import { SectionSnapShot } from "../../World/SnapShot/SectionSnapShot";
+export declare function MeshSectionSnapShot(snapShot: SectionSnapShot, transfers?: any[]): SetSectionMeshTask | null;

package/Mesher/Functions/MeshSectionSnapShot.js

@@ -0,0 +1,14 @@
+//tools
+import { MeshSectionBase } from "./Base/MeshSectionBase";
+import { SectionSnapshotCursor } from "../../World/SnapShot/SectionSnapShotCursor";
+let snapShotCursor;
+export function MeshSectionSnapShot(snapShot, transfers = []) {
+    if (!snapShotCursor)
+        snapShotCursor = new SectionSnapshotCursor();
+    const location = snapShot.location;
+    snapShotCursor.setSectionSnapShot(snapShot);
+    const sectionCursor = snapShotCursor.getCenteralCursor();
+    if (!sectionCursor)
+        return null;
+    return MeshSectionBase(snapShotCursor, sectionCursor, location, transfers);
+}

package/Mesher/Functions/MeshTexture.js

@@ -1,13 +1,17 @@
 import { Quad } from "../Geomtry/Primitives/Quad";
 const Quads = {
     north: Quad.Create([
-        [0, 0, 0],
         [1, 1, 0],
-    ], Quad.FullUVs, false, 1),
-    south: Quad.Create([
+        [0, 1, 0],
         [0, 0, 0],
+        [1, 0, 0],
+    ], Quad.FullUVs),
+    south: Quad.Create([
         [1, 1, 0],
-    ], Quad.FullUVs, false, 0),
+        [0, 1, 0],
+        [0, 0, 0],
+        [1, 0, 0],
+    ], Quad.FullUVs),
 };
 //const tool = new MesherDataTool();
 //tool.startNewMesh();

package/Mesher/Functions/MeshVoxel.js

@@ -1,15 +1,18 @@
 import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
 import { TemplateCursor } from "../../Templates/Cursor/TemplateCursor.js";
-import { FullVoxelTemplate } from "../../Templates/FullVoxelTemplate.js";
+import { FullVoxelTemplate } from "../../Templates/Full/FullVoxelTemplate.js";
 import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
 import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
+const template = new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf));
 const templateCursor = new TemplateCursor();
-templateCursor.setTemplate(new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf)));
+templateCursor.setTemplate(template);
 const space = new VoxelGeometryBuilderCacheSpace({ x: 3, y: 3, z: 3 });
 export function MeshVoxel(rawVoxelData) {
+    const index = template.getIndex(1, 1, 1);
+    template.ids[index] = rawVoxelData[0];
+    template.level[index] = rawVoxelData[2];
+    template.secondary[index] = rawVoxelData[3];
     const voxel = templateCursor.getVoxel(1, 1, 1);
-    voxel.copyRaw(rawVoxelData);
-    voxel.process();
     if (!voxel.isRenderable())
         return false;
     const constructor = VoxelModelConstructorRegister.getConstructor(voxel.getStringId());
@@ -17,6 +20,9 @@ export function MeshVoxel(rawVoxelData) {
         throw new Error(`Could not find constructor for voxel [id:${voxel.getStringId()} name:${voxel.getName()}] `);
     }
     const builder = constructor.builder;
+    if (!builder) {
+        console.error(builder, constructor.id, constructor);
+    }
     builder.space = space;
     builder.bvhTool = null;
     builder.clear();

package/Mesher/Geomtry/CompactedSectionVoxelMesh.d.ts

@@ -1,13 +1,16 @@
 import { Vec3Array } from "@amodx/math";
 import { LocationData } from "../../Math";
 export declare class CompactedMeshData {
-    material: string;
+    material: number;
+    materialId: string;
     minBounds: Vec3Array;
     maxBounds: Vec3Array;
+    vertexCount: number;
+    indexCount: number;
     vertexIndex: [start: number, length: number];
     indiceIndex: [start: number, length: number];
     verticies: Float32Array;
-    indices: Uint16Array | Uint32Array;
+    indices: Uint32Array;
 }
 export declare class CompactedSectionVoxelMesh {
     static GetHeaderByteSize(totalMeshes?: number): number;

package/Mesher/Geomtry/CompactedSectionVoxelMesh.js

@@ -1,8 +1,12 @@
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelMeshVertexStructCursor } from "./VoxelMeshVertexStructCursor";
 export class CompactedMeshData {
-    material = "dve_solid";
+    material;
+    materialId = "dve_solid";
     minBounds = [0, 0, 0];
     maxBounds = [0, 0, 0];
+    vertexCount = 0;
+    indexCount = 0;
     vertexIndex = [0, 0];
     indiceIndex = [0, 0];
     verticies;
@@ -73,7 +77,7 @@ export class CompactedSectionVoxelMesh {
         return location;
     }
     setMeshData(index, mesh) {
-        const { material, minBounds, maxBounds, vertexIndex, indiceIndex } = mesh;
+        const { materialId: material, minBounds, maxBounds, vertexIndex, indiceIndex, } = mesh;
         let startByte = CompactedSectionVoxelMesh.GetHeaderByteSize(0) +
             CompactedSectionVoxelMesh.GetMeshHeaderByteSize() * index;
         //material index
@@ -108,7 +112,8 @@ export class CompactedSectionVoxelMesh {
         let startByte = CompactedSectionVoxelMesh.GetHeaderByteSize(0) +
             CompactedSectionVoxelMesh.GetMeshHeaderByteSize() * index;
         // material index
-        mesh.material = VoxelPalettesRegister.material.getStringId(this.data.getUint8(startByte));
+        mesh.material = this.data.getUint8(startByte);
+        mesh.materialId = VoxelPalettesRegister.material.getStringId(mesh.material);
         startByte++;
         // min bounds
         mesh.minBounds[0] = this.data.getFloat32(startByte);
@@ -135,10 +140,10 @@ export class CompactedSectionVoxelMesh {
         mesh.indiceIndex[1] = this.data.getUint32(startByte);
         startByte += 4;
         mesh.verticies = new Float32Array(this.data.buffer, ...mesh.vertexIndex);
-        mesh.indices =
-            mesh.indiceIndex[1] > 65535
-                ? new Uint32Array(this.data.buffer, ...mesh.indiceIndex)
-                : new Uint16Array(this.data.buffer, ...mesh.indiceIndex);
+        mesh.indices = new Uint32Array(this.data.buffer, ...mesh.indiceIndex);
+        mesh.vertexCount =
+            mesh.vertexIndex[1] / VoxelMeshVertexStructCursor.VertexFloatSize;
+        mesh.indexCount = mesh.indiceIndex[1];
         return mesh;
     }
 }

package/Mesher/Geomtry/Functions/GetBounds.d.ts

@@ -0,0 +1,2 @@
+import { Vec3Array, Vector3Like } from "@amodx/math";
+export declare function GetBounds(...vectors: Vector3Like[]): [Vec3Array, Vec3Array];

package/Mesher/{Models/Common/BoundsFunctions.js → Geomtry/Functions/GetBounds.js}

@@ -1,4 +1,4 @@
-export function GetBounds(vectors) {
+export function GetBounds(...vectors) {
     let minX = Infinity;
     let minY = Infinity;
     let minZ = Infinity;
@@ -7,7 +7,7 @@ export function GetBounds(vectors) {
     let maxZ = -Infinity;
     const EPSILON = 0;
     for (let i = 0; i < vectors.length; i++) {
-        const [x, y, z] = vectors[i];
+        const { x, y, z } = vectors[i];
         if (x < minX)
             minX = x;
         if (y < minY)
@@ -22,17 +22,17 @@ export function GetBounds(vectors) {
             maxZ = z;
     }
     /*   if (maxX - minX < EPSILON) {
-        minX -= EPSILON / 2;
-        maxX += Number.EPSILON / 2;
-      }
-      if (maxY - minY < EPSILON) {
-        maxY -= EPSILON / 2;
-        minY += Number.EPSILON / 2;
-      }
-      if (maxZ - minZ < EPSILON) {
-        maxZ -= EPSILON / 2;
-        minZ += EPSILON / 2;
-      } */
+      minX -= EPSILON / 2;
+      maxX += Number.EPSILON / 2;
+    }
+    if (maxY - minY < EPSILON) {
+      maxY -= EPSILON / 2;
+      minY += Number.EPSILON / 2;
+    }
+    if (maxZ - minZ < EPSILON) {
+      maxZ -= EPSILON / 2;
+      minZ += EPSILON / 2;
+    } */
     return [
         [minX, minY, minZ],
         [maxX, maxY, maxZ],

package/Mesher/Geomtry/Geometry.types.d.ts

@@ -1,4 +1,12 @@
 import type { Vec2Array, Vec3Array } from "@amodx/math";
+export interface VoxelGeometryTransform {
+    position?: Vec3Array;
+    scale?: Vec3Array;
+    rotation?: Vec3Array;
+    rotationPivot?: Vec3Array;
+    lockUVs?: true;
+    flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
+}
 export type QuadVertexVec3Data = [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
 export type QuadVertexFloatData = [number, number, number, number];
 export type QuadUVData = [Vec2Array, Vec2Array, Vec2Array, Vec2Array];
@@ -9,3 +17,9 @@ export declare enum QuadVerticies {
     BottomRight = 3
 }
 export declare const QuadVerticiesArray: QuadVerticies[];
+export declare enum TriangleVerticies {
+    One = 0,
+    Two = 1,
+    Three = 2
+}
+export declare const TriangleVerticiesArray: TriangleVerticies[];