@divinevoxel/vlox 0.0.73 → 0.0.75

package/Math/CardinalNeighbors.d.ts

@@ -1,3 +1,43 @@
-export declare const $3dMooreNeighborhood: [number, number, number][];
-export declare const $2dMooreNeighborhood: [number, number][];
-export declare const $3dCardinalNeighbors: [number, number, number][];
+/**
+ * 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 declare const MooreNeighborhood2D: Readonly<[number, number][]>;
+/**
+ * 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 declare const MooreNeighborhood3D: Readonly<[number, number, number][]>;
+/**
+ * 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 declare const CardinalNeighbors3D: Readonly<[number, number, number][]>;
+/**
+* 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 declare const CardinalNeighbors2D: Readonly<[number, number][]>;

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,8 +1,3 @@
 export * from "./VoxelFaces.js";
 export * from "./VoxelFaces.js";
-export type LocationData = [
-    dimensionId: string,
-    x: number,
-    y: number,
-    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.d.ts

@@ -0,0 +1,4 @@
+import { SetSectionMeshTask } from "../Types/Mesher.types";
+import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
+import { LocationData } from "../../Math";
+export declare function CompactVoxelSectionMesh(location: LocationData, tools: VoxelModelBuilder[], transfers?: any[]): SetSectionMeshTask;

package/Mesher/Functions/CompactVoxelSectionMesh.js

@@ -0,0 +1,106 @@
+import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
+import { CompactedSectionVoxelMesh, CompactedMeshData, } from "../Geomtry/CompactedSectionVoxelMesh";
+const meshData = new CompactedMeshData();
+const compactedMesh = new CompactedSectionVoxelMesh();
+/** Utility to ensure a value is aligned to 4 bytes. */
+function align4(value) {
+    return (value + 3) & ~3;
+}
+export function CompactVoxelSectionMesh(location, tools, transfers = []) {
+    // 1) First compute how large the final buffer needs to be (with 4-byte alignment).
+    let headerSize = CompactedSectionVoxelMesh.GetHeaderByteSize(tools.length);
+    // Make the header itself 4-byte aligned
+    headerSize = align4(headerSize);
+    let totalByteCount = headerSize;
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        // Add the vertex data
+        const vertexByteSize = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexByteSize;
+        totalByteCount += vertexByteSize;
+        // Align after writing vertex data
+        totalByteCount = align4(totalByteCount);
+        // Add the index data
+        const indexByteSize = tool.mesh.indicieCount * 4;
+        totalByteCount += indexByteSize;
+        // Align after writing index data
+        totalByteCount = align4(totalByteCount);
+    }
+    // 2) Allocate the final buffer
+    const buffer = new ArrayBuffer(totalByteCount);
+    compactedMesh.setData(buffer);
+    compactedMesh.setLocation(...location);
+    compactedMesh.setTotalMeshes(tools.length);
+    // We'll track our position in the buffer here
+    let byteCount = headerSize;
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        // Fill out the meshData structure
+        meshData.materialId = tool.id;
+        const minBounds = tool.mesh.minBounds;
+        const maxBounds = tool.mesh.maxBounds;
+        meshData.minBounds[0] = minBounds.x;
+        meshData.minBounds[1] = minBounds.y;
+        meshData.minBounds[2] = minBounds.z;
+        meshData.maxBounds[0] = maxBounds.x;
+        meshData.maxBounds[1] = maxBounds.y;
+        meshData.maxBounds[2] = maxBounds.z;
+        // Vertex info
+        const totalVertFloats = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexFloatSize;
+        const vertexByteCount = totalVertFloats * 4;
+        meshData.vertexIndex[0] = byteCount;
+        meshData.vertexIndex[1] = totalVertFloats;
+        // Now move the pointer
+        byteCount += vertexByteCount;
+        // Align to 4 bytes again before writing indices
+        byteCount = align4(byteCount);
+        // Index info
+        meshData.indiceIndex[0] = byteCount;
+        meshData.indiceIndex[1] = tool.mesh.indicieCount;
+        const indexByteCount = tool.mesh.indicieCount * 4;
+        byteCount += indexByteCount;
+        // Align to 4 bytes for the next iteration (or final)
+        byteCount = align4(byteCount);
+        // Store the meta info
+        compactedMesh.setMeshData(i, meshData);
+        // Write vertex data
+        const vertexArray = new Float32Array(buffer, meshData.vertexIndex[0], totalVertFloats);
+        const vertexBuffers = tool.mesh.buffer._buffers;
+        let start = 0;
+        let done = false;
+        for (let b = 0; b < vertexBuffers.length; b++) {
+            const buf = vertexBuffers[b];
+            for (let j = 0; j < buf.length; j++) {
+                vertexArray[start] = buf[j];
+                start++;
+                if (start >= totalVertFloats) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+        // Write index data
+        const indicesArray = new Uint32Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount);
+        const indiceBuffers = tool.mesh.indices._buffers;
+        start = 0;
+        done = false;
+        for (let b = 0; b < indiceBuffers.length; b++) {
+            const buf = indiceBuffers[b];
+            for (let j = 0; j < buf.length; j++) {
+                indicesArray[start] = buf[j];
+                start++;
+                if (start >= tool.mesh.indicieCount) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+    }
+    // Transfer the ArrayBuffer to your worker if needed
+    transfers.push(buffer);
+    // Return the buffer or the task object as needed
+    return buffer;
+}

package/Mesher/Functions/MeshSection.d.ts

@@ -1,3 +1,3 @@
 import { LocationData } from "../../Math";
-import type { SetSectionMeshTask } from "../../Renderer/Renderer.types.js";
+import type { SetSectionMeshTask } from "../Types/Mesher.types";
 export declare function MeshSection(location: LocationData, transfers?: any[]): SetSectionMeshTask | null;

package/Mesher/Functions/MeshSection.js

@@ -1,126 +1,15 @@
-//data
-import { WorldSpaces } from "../../World/WorldSpaces.js";
 //tools
-import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
-import { CompactVoxelMesh } from "./CompactVoxelMesh.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 { 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.setDirty(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 volume = WorldSpaces.section.volumne;
-    const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
-    //const t = performance.now();
-    for (let i = 0; i < volume; 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);
-    }
-    // console.log(performance.now() - t);
-    const sectionEffects = [];
-    const sections = [
-        [location[0], ...section.getPosition()],
-        [],
-        sectionEffects,
-        0,
-    ];
-    const meshed = [];
-    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
-        const mesher = RenderedMaterials.meshers[i];
-        for (const e in mesher.effects) {
-            const float = Float32Array.from(mesher.effects[e]);
-            transfers.push(float.buffer);
-            sectionEffects.push([e, float]);
-        }
-        if (!mesher.mesh.vertexCount) {
-            mesher.clear();
-            mesher.bvhTool = null;
-            continue;
-        }
-        meshed.push(mesher);
-    }
-    const compactMesh = CompactVoxelMesh(meshed, transfers);
-    sections[1] = compactMesh;
-    for (let i = 0; i < meshed.length; i++) {
-        meshed[i].clear();
-        meshed[i].bvhTool = null;
-    }
-    section.setDirty(false);
-    section.setInProgress(false);
-    return sections;
+    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();