@divinevoxel/vlox 0.0.75 → 0.0.77

package/Mesher/{Models → Voxels/Models}/Nodes/Default/QuadVoxelGeometryNode.d.ts

@@ -1,6 +1,6 @@
 import { Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
+import { VoxelFaces } from "../../../../../Math";
+import { Quad } from "../../../../Geomtry/Primitives/Quad";
 import { GeoemtryNode } from "../GeometryNode";
 import { CompiledQuadVoxelGeomtryNode, QuadVoxelGometryArgs } from "../Types/QuadVoxelGometryNodeTypes";
 export declare class QuadVoxelGometryNode extends GeoemtryNode<CompiledQuadVoxelGeomtryNode, QuadVoxelGometryArgs> {

package/Mesher/{Models → Voxels/Models}/Nodes/Default/QuadVoxelGeometryNode.js

@@ -1,4 +1,4 @@
-import { Quad } from "../../../Geomtry/Primitives/Quad";
+import { Quad } from "../../../../Geomtry/Primitives/Quad";
 import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
 import { GeoemtryNode } from "../GeometryNode";
 import { QuadVoxelGometryInputs, } from "../Types/QuadVoxelGometryNodeTypes";

package/Mesher/{Models → Voxels/Models}/Nodes/Default/TriangleVoxelGeometryNode.d.ts

@@ -1,8 +1,8 @@
 import { Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
+import { VoxelFaces } from "../../../../../Math";
 import { GeoemtryNode } from "../GeometryNode";
 import { CompiledTriangleVoxelGeomtryNode, TriangleVoxelGometryArgs } from "../Types/TriangleVoxelGometryNodeTypes";
-import { Triangle } from "../../../Geomtry/Primitives/Triangle";
+import { Triangle } from "../../../../Geomtry/Primitives/Triangle";
 export declare class TriangleVoxelGeometryNode extends GeoemtryNode<CompiledTriangleVoxelGeomtryNode, TriangleVoxelGometryArgs> {
     triangle: Triangle;
     vertexWeights: Vec4Array[];

package/Mesher/{Models → Voxels/Models}/Nodes/Default/TriangleVoxelGeometryNode.js

@@ -2,7 +2,7 @@ import { addVoxelTriangle } from "../../../Geomtry/VoxelGeometryBuilder";
 import { GeoemtryNode } from "../GeometryNode";
 import { GetTexture } from "../../Common/GetTexture";
 import { TriangleVoxelGometryInputs, } from "../Types/TriangleVoxelGometryNodeTypes";
-import { Triangle } from "../../../Geomtry/Primitives/Triangle";
+import { Triangle } from "../../../../Geomtry/Primitives/Triangle";
 import { CullRulledFace } from "../../Common/Faces/CullRulledFace";
 import { ShadeRulledFace } from "../../Common/Faces/ShadeRulledFace";
 import { ShadeRulelessFace } from "../../Common/Faces/ShadeRulelessFace";

package/Mesher/{Models → Voxels/Models}/Nodes/Types/QuadVoxelGometryNodeTypes.d.ts

@@ -1,6 +1,6 @@
 import { Vec3Array, Vec4Array } from "@amodx/math";
-import { QuadUVData } from "../../../Geomtry/Geometry.types";
-import { VoxelFaces } from "../../../../Math";
+import { QuadUVData } from "../../../../Geomtry/Geometry.types";
+import { VoxelFaces } from "../../../../../Math";
 export type QuadVoxelGometryArgs = [
     enabled: boolean,
     texture: number,

package/Mesher/{Models → Voxels/Models}/Nodes/Types/TriangleVoxelGometryNodeTypes.d.ts

@@ -1,5 +1,5 @@
 import { Vec2Array, Vec3Array, Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
+import { VoxelFaces } from "../../../../../Math";
 export type TriangleVoxelGometryArgs = [
     enabled: boolean,
     texture: number,

package/Mesher/{Models → Voxels/Models}/Nodes/VoxelGeometryConstructor.d.ts

@@ -1,6 +1,6 @@
-import { CompiledVoxelGeometrySyncData } from "../../../Voxels/Models/CompiledVoxelModel.types";
+import { CompiledVoxelGeometrySyncData } from "../../../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNode } from "./GeometryNode";
-import { CullingProcedureData } from "../../../Voxels/Models/VoxelModel.types";
+import { CullingProcedureData } from "../../../../Voxels/Models/VoxelModel.types";
 export declare class VoxelGeometryConstructor {
     geometryPaletteId: number;
     nodes: GeoemtryNode<any, any>[];

package/Mesher/Voxels/Models/Procedures/Default/ConsistentRotationTextureProcedure.d.ts

@@ -0,0 +1,24 @@
+import { Vec3Array, Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Voxels/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "Textures";
+import { VoxelFaces } from "Math";
+/**
+ * Extend your data type so we can add a seed if we want, and define
+ * the rotations we can choose from.
+ */
+export interface ConsistentRotationTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "consistent-rotation";
+    texture: TextureId | number;
+    /**
+     * You can allow (0 | 90 | 180 | 270), or remove 0 if you don’t want an unrotated option
+     */
+    rotations: (0 | 90 | 180 | 270)[];
+    rotationBounds?: Vec3Array;
+}
+export declare class ConsistentRotationTextureProcedure extends TextureProcedure<ConsistentRotationTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: ConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: ConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: ConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}

package/Mesher/{Models → Voxels/Models}/Procedures/Default/ConsistentRotationTextureProcedure.js

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { TextureProcedure, } from "../TextureProcedure";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { GetYXZOrderArrayIndex } from "../../../../Math/Indexing";
+import { WorldSpaces } from "../../../../../World/WorldSpaces";
+import { GetYXZOrderArrayIndex } from "../../../../../Math/Indexing";
 const voxelPos = Vector3Like.Create();
 const defaultBounds = [4, 4, 4];
 export class ConsistentRotationTextureProcedure extends TextureProcedure {

package/Mesher/{Models → Voxels/Models}/Procedures/Default/OutlinedTextureProcedure.d.ts

@@ -1,10 +1,10 @@
 import { Vector4Like } from "@amodx/math";
-import type { Quad } from "../../../Geomtry";
-import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+import type { Quad } from "../../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Voxels/Models/VoxelModelBuilder";
 import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
 import { TextureId } from "Textures";
-import { VoxelFaces } from "../../../../Math/index.js";
-interface OutlinedTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+import { VoxelFaces } from "../../../../../Math/index.js";
+export interface OutlinedTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
     type: "outlined";
     texture: TextureId | number;
     textureRecrod: {
@@ -25,4 +25,3 @@ export declare class OutlinedTextureProcedure extends TextureProcedure<OutlinedT
     getOverlayTexture(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
     transformUVs(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
 }
-export {};

package/Mesher/Voxels/Models/Procedures/Default/OutlinedTextureProcedure.js

@@ -0,0 +1,205 @@
+import { TextureProcedure, } from "../TextureProcedure";
+import { VoxelFaceDirections, VoxelFaces } from "../../../../../Math/index.js";
+const textureMap = [
+    "top",
+    "corner-top-right",
+    "corner-top-left",
+    "corner-top-left-top-right",
+    "bottom",
+    "corner-bottom-right",
+    "corner-bottom-left",
+    "corner-bottom-left-bottom-right",
+    "right",
+    "left",
+];
+/*
+0 -> normal direction
+1 -> top right
+2 -> top left
+*/
+const uvsSets = {
+    //top bottom faces
+    north: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    south: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    east: {
+        0b0: 8,
+    },
+    west: {
+        0b0: 9,
+    },
+    //side faces
+    top: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    bottom: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    right: {
+        0b0: 8,
+    },
+    left: {
+        0b0: 9,
+    },
+};
+const CheckSets = {
+    [VoxelFaces.Up]: {
+        north: [
+            [0, 0, 1],
+            [1, 0, 1],
+            [-1, 0, 1],
+        ],
+        south: [
+            [0, 0, -1],
+            [1, 0, -1],
+            [-1, 0, -1],
+        ],
+        east: [[1, 0, 0]],
+        west: [[-1, 0, 0]],
+    },
+    [VoxelFaces.Down]: {
+        north: [
+            [0, 0, 1],
+            [1, 0, 1],
+            [-1, 0, 1],
+        ],
+        south: [
+            [0, 0, -1],
+            [1, 0, -1],
+            [-1, 0, -1],
+        ],
+        east: [[-1, 0, 0]],
+        west: [[1, 0, 0]],
+    },
+    [VoxelFaces.North]: {
+        north: [
+            [0, 1, 0],
+            [1, 1, 0],
+            [-1, 1, 0],
+        ],
+        south: [
+            [0, -1, 0],
+            [1, -1, 0],
+            [-1, -1, 0],
+        ],
+        east: [[-1, 0, 0]],
+        west: [[1, 0, 0]],
+    },
+    [VoxelFaces.South]: {
+        north: [
+            [0, 1, 0],
+            [1, 1, 0],
+            [-1, 1, 0],
+        ],
+        south: [
+            [0, -1, 0],
+            [1, -1, 0],
+            [-1, -1, 0],
+        ],
+        east: [[1, 0, 0]],
+        west: [[-1, 0, 0]],
+    },
+    [VoxelFaces.East]: {
+        north: [
+            [0, 1, 0],
+            [0, 1, 1],
+            [0, 1, -1],
+        ],
+        south: [
+            [0, -1, 0],
+            [0, -1, 1],
+            [0, -1, -1],
+        ],
+        east: [[0, 0, 1]],
+        west: [[0, 0, -1]],
+    },
+    [VoxelFaces.West]: {
+        north: [
+            [0, 1, 0],
+            [0, 1, 1],
+            [0, 1, -1],
+        ],
+        south: [
+            [0, -1, 0],
+            [0, -1, 1],
+            [0, -1, -1],
+        ],
+        east: [[0, 0, -1]],
+        west: [[0, 0, 1]],
+    },
+};
+const generateCheck = (direction, tool, normal, sets) => {
+    const { x, y, z } = tool.position;
+    let key = 0b0;
+    for (let i = 0; i < sets.length; i++) {
+        const set = sets[i];
+        const cx = x + set[0];
+        const cy = y + set[1];
+        const cz = z + set[2];
+        const sameLevelCheck = tool.nVoxel
+            .getVoxel(cx, cy, cz)
+            ?.isSameVoxel(tool.voxel);
+        let normalCheck = true;
+        const nVoxel = tool.nVoxel.getVoxel(cx + normal[0], cy + normal[1], cz + normal[2]);
+        if (nVoxel && nVoxel.isRenderable() && nVoxel.isOpaque()) {
+            normalCheck = false;
+        }
+        if (sameLevelCheck && normalCheck) {
+            key |= 0b1 << i;
+        }
+        else {
+            key |= 0b0 << i;
+            if (i == 0)
+                break;
+        }
+    }
+    if (uvsSets[direction][key] == undefined)
+        return 0;
+    const index = uvsSets[direction][key];
+    return textureMap[index];
+};
+export class OutlinedTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        return data.texture;
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        const set = CheckSets[closestFace];
+        const normal = VoxelFaceDirections[closestFace];
+        const isTopOrBottom = closestFace === VoxelFaces.Up || closestFace === VoxelFaces.Down;
+        // For top/bottom faces, use north/south/east/west sets.
+        // For side faces (north/south/east/west), use top/bottom/right/left sets.
+        const dirNorth = isTopOrBottom ? "north" : "top";
+        const dirSouth = isTopOrBottom ? "south" : "bottom";
+        const dirEast = isTopOrBottom ? "east" : "right";
+        const dirWest = isTopOrBottom ? "west" : "left";
+        const x = generateCheck(dirNorth, builder, normal, set.north);
+        if (x)
+            ref.x = data.textureRecrod[x];
+        const y = generateCheck(dirSouth, builder, normal, set.south);
+        if (y)
+            ref.y = data.textureRecrod[y];
+        const z = generateCheck(dirEast, builder, normal, set.east);
+        if (z)
+            ref.z = data.textureRecrod[z];
+        const w = generateCheck(dirWest, builder, normal, set.west);
+        if (w)
+            ref.w = data.textureRecrod[w];
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) { }
+}

package/Mesher/Voxels/Models/Procedures/Default/PillarTextureProcedure.d.ts

@@ -0,0 +1,28 @@
+import { Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Voxels/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "../../../../../Textures";
+import { VoxelFaces } from "../../../../../Math";
+/**
+ * Extend your data type so we can add a seed if we want, and define
+ * the rotations we can choose from.
+ */
+export interface PillarTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "pillar";
+    texture: TextureId | number;
+    textureRecrod: {
+        sideConnectedTex: TextureId | number;
+        sideDisconnectedTex: TextureId | number;
+        sideUpTex: TextureId | number;
+        sideDownTex: TextureId | number;
+        upTex: TextureId | number;
+        downTex: TextureId | number;
+    };
+    direction: "up-down" | "north-south" | "east-west";
+}
+export declare class PillarTextureProcedure extends TextureProcedure<PillarTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: PillarTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: PillarTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: PillarTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}

package/Mesher/Voxels/Models/Procedures/Default/PillarTextureProcedure.js

@@ -0,0 +1,109 @@
+import { TextureProcedure, } from "../TextureProcedure";
+import { VoxelFaces } from "../../../../../Math";
+export class PillarTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        if (data.direction == "up-down") {
+            if (closestFace == VoxelFaces.Up)
+                return data.textureRecrod.upTex;
+            if (closestFace == VoxelFaces.Down)
+                return data.textureRecrod.downTex;
+            let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const topVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y + 1, builder.position.z);
+            const topSame = topVoxel ? builder.voxel.isSameVoxel(topVoxel) : false;
+            const bottomVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y - 1, builder.position.z);
+            const bottomSame = bottomVoxel
+                ? builder.voxel.isSameVoxel(bottomVoxel)
+                : false;
+            if (topSame && !bottomSame) {
+                sideTexture = data.textureRecrod.sideDownTex;
+            }
+            if (!topSame && bottomSame) {
+                sideTexture = data.textureRecrod.sideUpTex;
+            }
+            if (topSame && bottomSame) {
+                sideTexture = data.textureRecrod.sideConnectedTex;
+            }
+            if (closestFace == VoxelFaces.North ||
+                closestFace == VoxelFaces.South ||
+                closestFace == VoxelFaces.East ||
+                closestFace == VoxelFaces.West)
+                return sideTexture;
+        }
+        if (data.direction == "north-south") {
+            if (closestFace == VoxelFaces.North)
+                return data.textureRecrod.upTex;
+            if (closestFace == VoxelFaces.South)
+                return data.textureRecrod.downTex;
+            let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const northVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y, builder.position.z + 1);
+            const northSame = northVoxel
+                ? builder.voxel.isSameVoxel(northVoxel)
+                : false;
+            const southVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y, builder.position.z - 1);
+            const southSame = southVoxel
+                ? builder.voxel.isSameVoxel(southVoxel)
+                : false;
+            if (northSame && !southSame) {
+                sideTexture = data.textureRecrod.sideDownTex;
+            }
+            if (!northSame && southSame) {
+                sideTexture = data.textureRecrod.sideUpTex;
+            }
+            if (northSame && southSame) {
+                sideTexture = data.textureRecrod.sideConnectedTex;
+            }
+            if (closestFace == VoxelFaces.Up ||
+                closestFace == VoxelFaces.Down ||
+                closestFace == VoxelFaces.East ||
+                closestFace == VoxelFaces.West)
+                return sideTexture;
+        }
+        if (data.direction == "east-west") {
+            if (closestFace == VoxelFaces.East)
+                return data.textureRecrod.upTex;
+            if (closestFace == VoxelFaces.West)
+                return data.textureRecrod.downTex;
+            let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const eastVoxel = builder.nVoxel.getVoxel(builder.position.x + 1, builder.position.y, builder.position.z);
+            const northSame = eastVoxel
+                ? builder.voxel.isSameVoxel(eastVoxel)
+                : false;
+            const westVoxel = builder.nVoxel.getVoxel(builder.position.x - 1, builder.position.y, builder.position.z);
+            const westSame = westVoxel ? builder.voxel.isSameVoxel(westVoxel) : false;
+            if (northSame && !westSame) {
+                sideTexture = data.textureRecrod.sideDownTex;
+            }
+            if (!northSame && westSame) {
+                sideTexture = data.textureRecrod.sideUpTex;
+            }
+            if (northSame && westSame) {
+                sideTexture = data.textureRecrod.sideConnectedTex;
+            }
+            if (closestFace == VoxelFaces.Up ||
+                closestFace == VoxelFaces.Down ||
+                closestFace == VoxelFaces.North ||
+                closestFace == VoxelFaces.South)
+                return sideTexture;
+        }
+        throw new Error(`Invalid direction for pillar box texture procedure | ${data.direction}`);
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) {
+        if ((data.direction == "north-south" &&
+            (closestFace == VoxelFaces.East || closestFace == VoxelFaces.West)) ||
+            (data.direction == "east-west" &&
+                (closestFace == VoxelFaces.North ||
+                    closestFace == VoxelFaces.South ||
+                    closestFace == VoxelFaces.Up ||
+                    closestFace == VoxelFaces.Down))) {
+            for (const v of primitive.uvs.vertices) {
+                const oldX = v.x;
+                const oldY = v.y;
+                v.x = 1 - oldY;
+                v.y = oldX;
+            }
+        }
+    }
+}

package/Mesher/{Models → Voxels/Models}/Procedures/TextureProcedure.d.ts

@@ -1,8 +1,8 @@
 import { Vector4Like } from "@amodx/math";
-import { Quad, Triangle } from "../../Geomtry";
+import { Quad, Triangle } from "../../../Geomtry";
 import { VoxelModelBuilder } from "../VoxelModelBuilder";
-import { VoxelFaces } from "../../../Math";
-import { TextureId } from "../../../Textures";
+import { VoxelFaces } from "../../../../Math";
+import { TextureId } from "../../../../Textures";
 export interface BaseVoxelGeomtryTextureProcedureData {
     type: string;
     texture?: TextureId | number;

package/Mesher/{Models → Voxels/Models}/Procedures/TextureProcedureRegister.js

@@ -1,5 +1,6 @@
 import { ConsistentRotationTextureProcedure } from "./Default/ConsistentRotationTextureProcedure";
 import { OutlinedTextureProcedure } from "./Default/OutlinedTextureProcedure";
+import { PillarTextureProcedure } from "./Default/PillarTextureProcedure";
 export class TextureProcedureRegister {
     static procedures = new Map();
     static register(id, procedure) {
@@ -14,3 +15,4 @@ export class TextureProcedureRegister {
 }
 TextureProcedureRegister.register("consistent-rotation", new ConsistentRotationTextureProcedure());
 TextureProcedureRegister.register("outlined", new OutlinedTextureProcedure());
+TextureProcedureRegister.register("pillar", new PillarTextureProcedure());

package/Mesher/{Models → Voxels/Models}/VoxelConstructor.d.ts

@@ -1,9 +1,9 @@
 import { VoxelModelBuilder } from "./VoxelModelBuilder";
-import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
-import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
-import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../../Voxels/Models/CompiledVoxelModel.types";
+import { StateSchema } from "../../../Voxels/State/Schema/StateSchema";
+import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 import { VoxelModelEffect } from "./VoxelModelEffect";
-import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
+import { CondtionalTreeReader } from "../../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
     id: string;
     builder: VoxelModelBuilder;

package/Mesher/{Models → Voxels/Models}/VoxelConstructor.js

@@ -1,8 +1,8 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
-import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { StateSchema } from "../../../Voxels/State/Schema/StateSchema";
+import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 import { VoxelModelEffect } from "./VoxelModelEffect";
-import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
+import { CondtionalTreeReader } from "../../../Voxels/State/CondiotnalTreeReader";
 export class VoxelConstructor {
     id;
     builder;

package/Mesher/{Models → Voxels/Models}/VoxelGeometryBuilderCacheSpace.d.ts

@@ -1,6 +1,6 @@
-import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
 import { Vec3Array, Vector3Like } from "@amodx/math";
-import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+import { VoxelCursor } from "../../../Voxels/Cursor/VoxelCursor";
 export declare class VoxelGeometryBuilderCacheSpace {
     bounds: Vector3Like;
     foundHash: Uint8Array;

package/Mesher/{Models → Voxels/Models}/VoxelGeometryBuilderCacheSpace.js

@@ -1,6 +1,6 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
-import { GetYXZOrderArrayIndex } from "../../Math/Indexing";
+import { VoxelCursor } from "../../../Voxels/Cursor/VoxelCursor";
+import { GetYXZOrderArrayIndex } from "../../../Math/Indexing";
 export class VoxelGeometryBuilderCacheSpace {
     bounds;
     foundHash;

package/Mesher/{Models → Voxels/Models}/VoxelModelBuilder.d.ts

@@ -1,11 +1,11 @@
-import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
-import { VoxelFaces } from "../../Math";
-import { QuadVerticies } from "../Geomtry/Geometry.types";
-import { VoxelMesh } from "../Geomtry/VoxelMesh";
+import { QuadScalarVertexData } from "../../Geomtry/Primitives/QuadVertexData";
+import { VoxelFaces } from "../../../Math";
+import { QuadVerticies } from "../../Geomtry/Geometry.types";
+import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
 import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
 import { Vec3Array, Vector3Like, Vector4Like } from "@amodx/math";
-import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
-import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface.js";
+import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface.js";
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface.js";
 import { VoxelGeometryBuilderCacheSpace } from "./VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
     textureIndex: number;
@@ -26,7 +26,7 @@ export declare class VoxelModelBuilder {
     position: Vector3Like;
     /**The current local origin  */
     origin: Vector3Like;
-    mesh: VoxelMesh;
+    mesh: ProtoMesh;
     bvhTool: VoxelMeshBVHBuilder | null;
     vars: VoxelVars;
     dataCalculated: Record<VoxelFaces, boolean>;

package/Mesher/{Models → Voxels/Models}/VoxelModelBuilder.js

@@ -1,11 +1,12 @@
 //tools
 //data
-import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
-import { VoxelFaces, VoxelFacesArray } from "../../Math";
-import { QuadVerticies } from "../Geomtry/Geometry.types";
+import { QuadScalarVertexData } from "../../Geomtry/Primitives/QuadVertexData";
+import { VoxelFaces, VoxelFacesArray } from "../../../Math";
+import { QuadVerticies } from "../../Geomtry/Geometry.types";
 import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
-import { VoxelMesh } from "../Geomtry/VoxelMesh";
+import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
+import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
 class VoxelVars {
     textureIndex = 0;
     overlayTextures = Vector4Like.Create();
@@ -31,7 +32,7 @@ export class VoxelModelBuilder {
     position = Vector3Like.Create();
     /**The current local origin  */
     origin = Vector3Like.Create();
-    mesh = new VoxelMesh();
+    mesh = new ProtoMesh(VoxelMeshVertexStructCursor.VertexFloatSize);
     bvhTool = null;
     vars = new VoxelVars();
     dataCalculated;

package/Mesher/{Models → Voxels/Models}/VoxelModelConstructorRegister.d.ts

@@ -1,10 +1,10 @@
-import { StringPalette } from "../../Util/StringPalette";
-import { CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
+import { StringPalette } from "../../../Util/StringPalette";
+import { CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
 import { VoxelConstructor } from "./VoxelConstructor";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
-import { AOOcclusionFaceIndex } from "../../Voxels/Models/Indexing/AOOcclusionFaceIndex";
-import { CulledOcclusionFaceIndex } from "../../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
+import { AOOcclusionFaceIndex } from "../../../Voxels/Models/Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../../../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export declare class VoxelModelConstructorRegister {
     static geometryPalette: StringPalette;
     static geometry: VoxelGeometryConstructor[];

package/Mesher/{Models → Voxels/Models}/VoxelModelConstructorRegister.js

@@ -1,6 +1,6 @@
-import { StringPalette } from "../../Util/StringPalette";
+import { StringPalette } from "../../../Util/StringPalette";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
-import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
 export class VoxelModelConstructorRegister {
     static geometryPalette;
     static geometry = [];

package/Mesher/{Models → Voxels/Models}/VoxelModelEffect.d.ts

@@ -1,5 +1,5 @@
 import { VoxelConstructor } from "./VoxelConstructor";
-import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 export declare class VoxelModelEffect {
     model: VoxelConstructor;

package/Mesher/{Models → Voxels/Models}/VoxelModelEffect.js

@@ -1,4 +1,4 @@
-import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 export class VoxelModelEffect {
     model;
     effects = [];

package/Renderer/Classes/DVESectionMeshes.d.ts

@@ -1,5 +1,5 @@
 import { SectionMesh } from "./SectionMesh";
-import { CompactedSectionVoxelMesh } from "../../Mesher/Geomtry/CompactedSectionVoxelMesh";
+import { CompactedSectionVoxelMesh } from "../../Mesher/Voxels/Geomtry/CompactedSectionVoxelMesh";
 export declare abstract class DVESectionMeshes {
     abstract updateVertexData(section: SectionMesh, data: CompactedSectionVoxelMesh): SectionMesh;
     abstract returnMesh(mesh: any): void;