@divinevoxel/vlox 0.0.4 → 0.0.6

package/Math/VoxelMath.js

@@ -1,47 +0,0 @@
-import { BoundingBox } from "./Classes/BoundingBox.js";
-import { Plane } from "./Classes/Plane.js";
-import { SimpleBoundingBox } from "./Classes/SimpleBoundingBox.js";
-import { Vector3 } from "./Classes/Vector3.js";
-import { VisitAll } from "./VisitAll.js";
-/**# Voxel Math
- * ---
- * Can be used in any thread that needs it.
- * Has functions for collision detection, finding voxels in a direction, and path finding.
- */
-export const VoxelMath = {
-    visitAll: VisitAll,
-    getVector3(x, y, z) {
-        return new Vector3(x, y, z);
-    },
-    getPlane(pv1, pv2, pv3, pv4) {
-        return new Plane({
-            v1: pv1,
-            v2: pv2,
-            v3: pv3,
-            v4: pv4,
-        });
-    },
-    getSimpleBoundingBox(origin, dimensions) {
-        return new SimpleBoundingBox(origin, dimensions);
-    },
-    getBoundingBox(data) {
-        return new BoundingBox(data);
-    },
-    convertToOriginGridSpace(position) {
-        position[0] = Math.round(position[0]) + 0.5;
-        position[1] = Math.round(position[1]) + 0.5;
-        position[2] = Math.round(position[2]) + 0.5;
-        return position;
-    },
-    distance2D(x1, x2, y1, y2) {
-        var dx = x2 - x1;
-        var dy = y2 - y1;
-        return Math.sqrt(dx * dx + dy * dy);
-    },
-    distance3D(x1, y1, z1, x2, y2, z2) {
-        const a = x2 - x1;
-        const b = y2 - y1;
-        const c = z2 - z1;
-        return Math.sqrt(a * a + b * b + c * c);
-    },
-};

package/Mesher/Geometry/VoxelGeometry.d.ts

@@ -1,7 +0,0 @@
-import { Vector3Like, Vec2Array, Vec3Array } from "@amodx/math";
-import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
-export declare class VoxelGeometry {
-    static addTriangle(tool: VoxelMesherDataTool, origin: Vector3Like, points: [Vec3Array, Vec3Array, Vec3Array], [[u1, v1], [u2, v2], [u3, v3]]: [Vec2Array, Vec2Array, Vec2Array]): void;
-    static addQuad(tool: VoxelMesherDataTool, origin: Vector3Like, quad: Quad): void;
-}

package/Mesher/Geometry/VoxelGeometry.js

@@ -1,115 +0,0 @@
-import { VoxelShaderData } from "../../Voxels/VoxelShaderData";
-import { GeometryBuilder } from "@amodx/meshing/Geometry/GeometryBuilder";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types";
-export class VoxelGeometry {
-    static addTriangle(tool, origin, points, [[u1, v1], [u2, v2], [u3, v3]]) {
-        if (!tool.mesh)
-            return;
-        const worldLight = tool.getWorldLight();
-        const worldAO = tool.getWorldAO();
-        const texture = tool.getTexture();
-        GeometryBuilder.addTriangle(tool, origin, points);
-        {
-            const attribute = tool.mesh.getAttribute("voxelData");
-            attribute.push(VoxelShaderData.createAttribute(worldLight.vertices[1], worldAO.vertices[1], 0), VoxelShaderData.createAttribute(worldLight.vertices[2], worldAO.vertices[2], 0), VoxelShaderData.createAttribute(worldLight.vertices[3], worldAO.vertices[3], 9));
-        }
-        {
-            const uvs = tool.mesh.getAttribute("uv");
-            uvs.push(u1, v1, texture, u2, v2, texture, u3, v3, texture);
-        }
-        {
-            const uvs = tool.mesh.getAttribute("textureIndex");
-            uvs.push(
-            //v1
-            0, 0, 0, 0, 
-            //v2
-            0, 0, 0, 0, 
-            //v3
-            0, 0, 0, 0);
-        }
-        {
-            const colors = tool.mesh.getAttribute("colors");
-            colors.push(
-            //v1
-            0, 0, 0, 
-            //v2
-            0, 0, 0, 
-            //v3
-            0, 0, 0);
-        }
-    }
-    static addQuad(tool, origin, quad) {
-        if (!tool.mesh)
-            return;
-        GeometryBuilder.addQuad(tool, origin, quad);
-        const worldLight = tool.getWorldLight();
-        const worldAO = tool.getWorldAO();
-        const animData = tool.getAnimationData();
-        const texture = tool.getTexture();
-        const overlayTextures = tool.getOverlayTextures();
-        const attribute = tool.mesh.getAttribute("voxelData");
-        const uvs = tool.mesh.getAttribute("uv");
-        const textureIndex = tool.mesh.getAttribute("textureIndex");
-        const colors = tool.mesh.getAttribute("colors");
-        let sides = quad.doubleSided ? 2 : 1;
-        let attrIndex = attribute.length;
-        let uvIndex = uvs.length;
-        let textureIndexIndex = textureIndex.length;
-        let colorIndex = colors.length;
-        while (sides--) {
-            if (!quad.flip) {
-                attribute[attrIndex++] = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopRight], animData.vertices[QuadVerticies.TopRight]);
-                attribute[attrIndex++] = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.TopLeft], animData.vertices[QuadVerticies.TopLeft]);
-                attribute[attrIndex++] = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomLeft], animData.vertices[QuadVerticies.BottomLeft]);
-                attribute[attrIndex++] = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomRight]);
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.TopRight].x;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.TopRight].y;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.TopLeft].x;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.TopLeft].y;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.BottomLeft].x;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.BottomLeft].y;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.BottomRight].x;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.BottomRight].y;
-            }
-            else {
-                attribute[attrIndex++] = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.TopLeft], animData.vertices[QuadVerticies.TopLeft]);
-                attribute[attrIndex++] = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopRight], animData.vertices[QuadVerticies.TopRight]);
-                attribute[attrIndex++] = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomRight]);
-                attribute[attrIndex++] = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomLeft], animData.vertices[QuadVerticies.BottomLeft]);
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.TopLeft].x;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.TopLeft].y;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.TopRight].x;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.TopRight].y;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.BottomRight].x;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.BottomRight].y;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.BottomLeft].x;
-                uvs[uvIndex++] = quad.uvs.vertices[QuadVerticies.BottomLeft].y;
-            }
-            //1
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(texture, overlayTextures.vertices[QuadVerticies.TopRight]);
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.TopLeft], overlayTextures.vertices[QuadVerticies.BottomLeft]);
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.BottomRight], 0);
-            //2
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(texture, overlayTextures.vertices[QuadVerticies.TopRight]);
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.TopLeft], overlayTextures.vertices[QuadVerticies.BottomLeft]);
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.BottomRight], 0);
-            //3
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(texture, overlayTextures.vertices[QuadVerticies.TopRight]);
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.TopLeft], overlayTextures.vertices[QuadVerticies.BottomLeft]);
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.BottomRight], 0);
-            //4
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(texture, overlayTextures.vertices[QuadVerticies.TopRight]);
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.TopLeft], overlayTextures.vertices[QuadVerticies.BottomLeft]);
-            textureIndex[textureIndexIndex++] = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.BottomRight], 0);
-            for (let i = 0; i < 4; i++) {
-                colors[colorIndex++] = 0;
-                colors[colorIndex++] = 0;
-                colors[colorIndex++] = 0;
-            }
-        }
-        attribute.length = attrIndex;
-        uvs.length = uvIndex;
-        textureIndex.length = textureIndexIndex;
-        colors.length = colorIndex;
-    }
-}

package/Mesher/Mesher.d.ts

@@ -1,16 +0,0 @@
-import { LocationData } from "../Math/index.js";
-import { ChunkProcessor } from "./Processors/ChunkProcessor.js";
-import { BuildNodeMesh } from "./Tasks/BuidlerTasks.types.js";
-import { DataSyncData } from "../Contexts/Base/Remote/Sync/DataSync.types.js";
-export declare class DVEMesher {
-    static instance: DVEMesher;
-    chunkProcessor: ChunkProcessor;
-    nodes: {
-        builders: Map<string, import("./Meshers/MesherInterface.js").MesherInterface>;
-        registerBuilder(builder: import("./Meshers/MesherInterface.js").MesherInterface): void;
-        buildNode(data: BuildNodeMesh): [import("./Tasks/BuidlerTasks.types.js").SetNodeMesh, ArrayBuffer[]] | false;
-    };
-    constructor();
-    init(data: DataSyncData): void;
-    meshChunk(location: LocationData, LOD?: number, priority?: number): boolean;
-}

package/Mesher/Mesher.js

@@ -1,44 +0,0 @@
-import { ChunkProcessor } from "./Processors/ChunkProcessor.js";
-import { MesherManager } from "./Meshers/MesherManager.js";
-import { RenderedSubstances } from "./Substances/RenderedSubstances.js";
-import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
-import { LiquidGeometryNode } from "./Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
-import { SchemaRegister } from "../Voxels/State/SchemaRegister.js";
-import { VoxelTagStates } from "../Voxels/State/VoxelTagStates.js";
-import { VoxelConstructor } from "./Models/VoxelConstructor.js";
-export class DVEMesher {
-    static instance;
-    chunkProcessor = new ChunkProcessor();
-    nodes = MesherManager;
-    constructor() {
-        if (!DVEMesher.instance)
-            DVEMesher.instance = this;
-        return DVEMesher.instance;
-    }
-    init(data) {
-        for (const mat of data.materials.palette) {
-            RenderedSubstances.add(mat);
-        }
-        if (data.modelData) {
-            const modelData = data.modelData;
-            VoxelModelConstructorRegister.registerCustomNode("liquid", LiquidGeometryNode);
-            VoxelModelConstructorRegister.setGeometryPalette(modelData.geometryPalette);
-            VoxelModelConstructorRegister.registerGeometry(modelData.geometry);
-            VoxelModelConstructorRegister.registerModels(modelData.models);
-            for (const model of modelData.models) {
-                SchemaRegister.registerModel(model.id, model.schema);
-            }
-            for (const voxel of modelData.voxels) {
-                SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
-            }
-            VoxelTagStates.load(modelData.tagState);
-            for (const voxel of modelData.voxels) {
-                VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel.id, VoxelModelConstructorRegister.modelData.get(voxel.modelId), voxel));
-            }
-        }
-    }
-    meshChunk(location, LOD = 1, priority = 0) {
-        this.chunkProcessor.build(location);
-        return true;
-    }
-}

package/Mesher/Meshers/MesherInterface.d.ts

@@ -1,5 +0,0 @@
-import { BuildNodeMesh, SetNodeMesh } from "../Tasks/BuidlerTasks.types";
-export interface MesherInterface {
-    id: string;
-    build(data: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
-}

package/Mesher/Meshers/MesherManager.d.ts

@@ -1,7 +0,0 @@
-import type { MesherInterface } from "./MesherInterface";
-import { BuildNodeMesh, SetNodeMesh } from "../Tasks/BuidlerTasks.types";
-export declare const MesherManager: {
-    builders: Map<string, MesherInterface>;
-    registerBuilder(builder: MesherInterface): void;
-    buildNode(data: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
-};

package/Mesher/Meshers/MesherManager.js

@@ -1,16 +0,0 @@
-import { TextureBuilder } from "./TextureMesher.js";
-import { VoxelBuilder } from "./VoxelMesher.js";
-export const MesherManager = {
-    builders: new Map(),
-    registerBuilder(builder) {
-        this.builders.set(builder.id, builder);
-    },
-    buildNode(data) {
-        const builder = this.builders.get(data[1]);
-        if (!builder)
-            return false;
-        return builder.build(data);
-    },
-};
-MesherManager.registerBuilder(TextureBuilder);
-MesherManager.registerBuilder(VoxelBuilder);

package/Mesher/Meshers/TextureMesher.d.ts

@@ -1,15 +0,0 @@
-import { MesherInterface } from "./MesherInterface.js";
-import { BuildNodeMesh, SetNodeMesh } from "../Tasks/BuidlerTasks.types.js";
-/**
- * @todo
- * For 32x32 textures the uvs and pixels are not correct.
- * Some pixels seem to be missing and the uvs are off slightly.
- * Added the uv offset for now to make it look a little better but pixels are still missing.
- */
-declare class TXTBuilderBase implements MesherInterface {
-    id: string;
-    constructor(id: string);
-    build(buildTask: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]];
-}
-export declare const TextureBuilder: TXTBuilderBase;
-export {};

package/Mesher/Meshers/TextureMesher.js

@@ -1,191 +0,0 @@
-import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools.js";
-import { BinaryNumberTypes } from "@amodx/binary";
-import { Quad } from "@amodx/meshing/Primitives/Quad.js";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types.js";
-import { GeometryBuilder } from "@amodx/meshing";
-import { Flat2DIndex, Vector3Like } from "@amodx/math";
-import { CompactMesh } from "../Functions/CompactMesh.js";
-const Quads = {
-    north: Quad.Create([
-        [0, 0, 0],
-        [1, 1, 0],
-    ], Quad.FullUVs, false, 1),
-    south: Quad.Create([
-        [0, 0, 0],
-        [1, 1, 0],
-    ], Quad.FullUVs, false, 0),
-};
-const tool = new MesherDataTool();
-tool.startNewMesh();
-tool.mesh.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
-tool.mesh.attributes.set("textureIndex", [[], 3, BinaryNumberTypes.Float32]);
-/**
- * @todo
- * For 32x32 textures the uvs and pixels are not correct.
- * Some pixels seem to be missing and the uvs are off slightly.
- * Added the uv offset for now to make it look a little better but pixels are still missing.
- */
-class TXTBuilderBase {
-    id;
-    constructor(id) {
-        this.id = id;
-    }
-    build(buildTask) {
-        const [location, type, data] = buildTask;
-        const textureId = data.textureId;
-        const textureData = data.textureData;
-        tool.setVar("texture", textureId);
-        const width = Math.sqrt(textureData.length / 4);
-        const height = Math.sqrt(textureData.length / 4);
-        const factor = 1 / width;
-        const textureDataIndex = Flat2DIndex.GetXYOrder();
-        textureDataIndex.setBounds(width, height);
-        const origin = Vector3Like.Create(-0.5, -0.5, -0.5);
-        const isSolid = (x, y) => x >= 0 &&
-            x < width &&
-            y >= 0 &&
-            y < height &&
-            textureData[textureDataIndex.getIndexXY(x, y) * 4 + 3] > 0.01
-            ? true
-            : false;
-        const uvs = tool.mesh.getAttribute("uv");
-        const textureIndex = tool.mesh.getAttribute("textureIndex");
-        const uvOffset = width > 16 ? -(2 / Math.max(width, height)) : 0;
-        const addUvs = (sx, sy, ex, ey) => {
-            uvs.push((ex + uvOffset) * factor, (ey + uvOffset) * factor, (sx - uvOffset) * factor, (ey + uvOffset) * factor, (sx - uvOffset) * factor, (sy - uvOffset) * factor, (ex + uvOffset) * factor, (sy - uvOffset) * factor);
-            textureIndex.push(textureId, 0, 0, textureId, 0, 0, textureId, 0, 0, textureId, 0, 0);
-        };
-        {
-            GeometryBuilder.addQuad(tool, origin, Quads.south);
-            uvs.push(Quads.south.uvs.vertices[QuadVerticies.TopRight].x, Quads.south.uvs.vertices[QuadVerticies.TopRight].y, Quads.south.uvs.vertices[QuadVerticies.TopLeft].x, Quads.south.uvs.vertices[QuadVerticies.TopLeft].y, Quads.south.uvs.vertices[QuadVerticies.BottomLeft].x, Quads.south.uvs.vertices[QuadVerticies.BottomLeft].y, Quads.south.uvs.vertices[QuadVerticies.BottomRight].x, Quads.south.uvs.vertices[QuadVerticies.BottomRight].y);
-            textureIndex.push(textureId, 0, 0, textureId, 0, 0, textureId, 0, 0, textureId, 0, 0);
-        }
-        {
-            const backPositionZ = factor;
-            Quads.north.positions.vertices[QuadVerticies.TopRight].z = backPositionZ;
-            Quads.north.positions.vertices[QuadVerticies.TopLeft].z = backPositionZ;
-            Quads.north.positions.vertices[QuadVerticies.BottomLeft].z =
-                backPositionZ;
-            Quads.north.positions.vertices[QuadVerticies.BottomRight].z =
-                backPositionZ;
-            Quads.north.flip = true;
-            uvs.push(Quads.north.uvs.vertices[QuadVerticies.TopLeft].x, Quads.north.uvs.vertices[QuadVerticies.TopLeft].y, Quads.north.uvs.vertices[QuadVerticies.TopRight].x, Quads.north.uvs.vertices[QuadVerticies.TopRight].y, Quads.north.uvs.vertices[QuadVerticies.BottomRight].x, Quads.north.uvs.vertices[QuadVerticies.BottomRight].y, Quads.north.uvs.vertices[QuadVerticies.BottomLeft].x, Quads.north.uvs.vertices[QuadVerticies.BottomLeft].y);
-            GeometryBuilder.addQuad(tool, origin, Quads.north);
-            textureIndex.push(textureId, 0, 0, textureId, 0, 0, textureId, 0, 0, textureId, 0, 0);
-        }
-        for (let x = 0; x < width; x++) {
-            let eastFace = null;
-            let westFace = null;
-            for (let y = 0; y < height; y++) {
-                let eastFaceExposed = true;
-                let westFaceExposed = true;
-                if (!isSolid(x, y)) {
-                    eastFaceExposed = false;
-                    westFaceExposed = false;
-                }
-                if (isSolid(x + 1, y)) {
-                    eastFaceExposed = false;
-                }
-                if (isSolid(x - 1, y)) {
-                    westFaceExposed = false;
-                }
-                if (eastFace && !eastFaceExposed) {
-                    const newQuad = Quad.Create([
-                        [x * factor + factor, eastFace[1] * factor, 0],
-                        [x * factor + factor, y * factor, factor],
-                    ], Quad.FullUVs, false, 0);
-                    GeometryBuilder.addQuad(tool, origin, newQuad);
-                    let [sx, sy] = eastFace;
-                    let ex = x;
-                    let ey = y;
-                    ex += 1;
-                    addUvs(sx, sy, ex, ey);
-                    eastFace = null;
-                }
-                if (westFace && !westFaceExposed) {
-                    const newQuad = Quad.Create([
-                        [x * factor, westFace[1] * factor, 0],
-                        [x * factor, y * factor, factor],
-                    ], Quad.FullUVs, false, 1);
-                    GeometryBuilder.addQuad(tool, origin, newQuad);
-                    let [sx, sy] = westFace;
-                    let ex = x;
-                    let ey = y;
-                    ex += 1;
-                    addUvs(sx, sy, ex, ey);
-                    westFace = null;
-                }
-                const isPixel = isSolid(x, y);
-                if (!isSolid(x + 1, y) && !eastFace && isPixel) {
-                    eastFace = [x, y];
-                }
-                if (!isSolid(x - 1, y) && !westFace && isPixel) {
-                    westFace = [x, y];
-                }
-            }
-        }
-        for (let y = 0; y < height; y++) {
-            let upFace = null;
-            let downFace = null;
-            for (let x = 0; x < width; x++) {
-                let upFaceExposed = true;
-                let downFaceExposed = true;
-                if (!isSolid(x, y)) {
-                    upFaceExposed = false;
-                    downFaceExposed = false;
-                }
-                if (isSolid(x, y + 1)) {
-                    upFaceExposed = false;
-                }
-                if (isSolid(x, y - 1)) {
-                    downFaceExposed = false;
-                }
-                if (upFace && !upFaceExposed) {
-                    const newQuad = Quad.Create([
-                        [upFace[0] * factor, y * factor + factor, 0],
-                        [x * factor, y * factor + factor, factor],
-                    ], Quad.FullUVs, false, 0);
-                    GeometryBuilder.addQuad(tool, origin, newQuad);
-                    let [sx, sy] = upFace;
-                    let [ex, ey] = [x, y];
-                    ey += 1;
-                    addUvs(sx, sy, ex, ey);
-                    upFace = null;
-                }
-                if (downFace && !downFaceExposed) {
-                    const newQuad = Quad.Create([
-                        [downFace[0] * factor, y * factor, 0],
-                        [x * factor, y * factor, factor],
-                    ], Quad.FullUVs, false, 1);
-                    GeometryBuilder.addQuad(tool, origin, newQuad);
-                    let [sx, sy] = downFace;
-                    let [ex, ey] = [x, y];
-                    ey += 1;
-                    addUvs(sx, sy, ex, ey);
-                    downFace = null;
-                }
-                const isPixel = isSolid(x, y);
-                if (!isSolid(x, y + 1) && !upFace && isPixel) {
-                    upFace = [x, y];
-                }
-                if (!isSolid(x, y - 1) && !downFace && isPixel) {
-                    downFace = [x, y];
-                }
-            }
-        }
-        for (const [key, [data]] of tool.mesh.attributes) {
-            if (key == "position") {
-                for (let i = 0; i < data.length; i += 3) {
-                    data[i] -= 0.5;
-                    data[i + 1] -= 0.5;
-                    data[i + 2];
-                }
-            }
-        }
-        const compacted = CompactMesh("dve_node", tool);
-        tool.resetVars();
-        tool.mesh.clear();
-        return [[location, compacted], [compacted[1]]];
-    }
-}
-export const TextureBuilder = new TXTBuilderBase("dve_node");

package/Mesher/Meshers/VoxelMesher.d.ts

@@ -1,15 +0,0 @@
-import { MesherInterface } from "./MesherInterface.js";
-import { BuildNodeMesh, SetNodeMesh } from "../Tasks/BuidlerTasks.types.js";
-import { TemplateCursor } from "../../Data/Cursor/Template/TemplateCursor.js";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
-declare class VoxelBuilderBase implements MesherInterface {
-    id: string;
-    templateCursor: TemplateCursor;
-    voxelCursor: VoxelCursor;
-    substanceData: SubstanceDataTool;
-    constructor(id: string);
-    build([location, type, rawVoxelData]: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
-}
-export declare const VoxelBuilder: VoxelBuilderBase;
-export {};

package/Mesher/Meshers/VoxelMesher.js

@@ -1,47 +0,0 @@
-import { RenderedSubstances } from "../Substances/RenderedSubstances.js";
-import { VoxelGeometryLookUp } from "../Models/VoxelGeometryLookUp.js";
-import { TemplateCursor } from "../../Data/Cursor/Template/TemplateCursor.js";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
-import { FullVoxelTemplate } from "../../Templates/FullVoxelTemplate.js";
-import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
-import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
-class VoxelBuilderBase {
-    id;
-    templateCursor = new TemplateCursor();
-    voxelCursor = new VoxelCursor();
-    substanceData = new SubstanceDataTool();
-    constructor(id) {
-        this.id = id;
-        this.templateCursor.setTemplate(new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf)));
-    }
-    build([location, type, rawVoxelData]) {
-        const voxel = this.templateCursor.getVoxel(1, 1, 1);
-        voxel.copyRaw(rawVoxelData);
-        voxel.process();
-        if (!voxel.isRenderable())
-            return false;
-        const constructor = VoxelModelConstructorRegister.getConstructor(voxel.getStringId());
-        const mesher = RenderedSubstances.meshers.get(voxel.getRenderedMaterialStringId());
-        if (!mesher || !constructor)
-            return false;
-        mesher.resetAll();
-        VoxelGeometryLookUp.start("main", 0, 0, 0);
-        mesher.origin.x = -0.5;
-        mesher.origin.y = -0.5;
-        mesher.origin.z = -0.5;
-        mesher.position.x = 1;
-        mesher.position.y = 1;
-        mesher.position.z = 1;
-        mesher.voxel = this.voxelCursor.copy(voxel);
-        mesher.nVoxel = this.templateCursor;
-        constructor.process(mesher);
-        mesher.resetVars();
-        VoxelGeometryLookUp.stop();
-        const compacted = CompactVoxelMesh(mesher);
-        mesher.resetVars();
-        mesher.mesh.clear();
-        return [[location, compacted], [compacted[1]]];
-    }
-}
-export const VoxelBuilder = new VoxelBuilderBase("dve_node_voxel");

package/Mesher/Processors/ChunkProcessor.d.ts

@@ -1,13 +0,0 @@
-import type { LocationData } from "../../Math/index.js";
-import { HeightMapTool } from "../../Tools/Data/WorldData/HeightMapTool.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
-import { ChunkCursor } from "../../Data/Cursor/World/ChunkCursor.js";
-export declare class ChunkProcessor {
-    heightMapTool: HeightMapTool;
-    substanceData: SubstanceDataTool;
-    chunkCursor: ChunkCursor;
-    worldCursor: WorldCursor;
-    _process(x: number, y: number, z: number, doSecondCheck?: boolean): boolean;
-    build(location: LocationData, priority?: number): void;
-}