@divinevoxel/vlox 0.0.0

package/Mesher/Mesher.d.ts

@@ -0,0 +1,80 @@
+import { LocationData } from "../Math/index.js";
+import { VoxelConstructorsRegister } from "./Constructors/Voxel/VoxelConstructorsRegister.js";
+import { ChunkProcessor } from "./Processors/ChunkProcessor.js";
+import { OverrideManager } from "./Rules/Overrides/OverridesManager.js";
+import { RenderedSubstances } from "./Rules/RenderedSubstances.js";
+import { BuildNodeMesh } from "./Tasks/BuidlerTasks.types.js";
+import { VoxelConstructor } from "./Constructors/Voxel/Classes/VoxelConstructor.js";
+import { VoxelShapeManager } from "./Shapes/VoxelShapeManager.js";
+import { Observable } from "@amodx/core/Observers";
+export type DVEMesherInitData = {
+    constructors: VoxelConstructor[];
+};
+export declare class DVEMesher {
+    static observers: {
+        texturesRegistered: Observable<{
+            textureDataHasBeenSet: boolean;
+            data: import("../Textures/Texture.types.js").TextureTypeUVMap;
+            getTextureUV(data: import("../Textures/Constructor.types.js").ConstructorTextureData, overlay?: boolean): number;
+            setTextureIndex(data: import("../Textures/Texture.types.js").TextureTypeUVMap): void;
+            releaseTextureData(): void;
+            isReady(): boolean;
+        }>;
+    };
+    static instance: DVEMesher;
+    static get defaults(): {
+        cube: {
+            mod(id: string, textures: import("../Textures/Constructor.types.js").ConstructorTextureData[] | Record<import("../Math/index.js").VoxelFaces, import("../Textures/Constructor.types.js").ConstructorTextureData[]>): import("./Constructors/Voxel/Classes/Cube/ModCube.constructor.js").ModCubeVoxelConstructor;
+            simple(id: string, textures: import("../Textures/Constructor.types.js").ConstructorTextureData | Record<import("../Types/Util.types.js").DirectionNames, import("../Textures/Constructor.types.js").ConstructorTextureData>): import("./Constructors/Voxel/Classes/Cube/SimpleCube.constructor.js").SimpleCubeVoxelConstructor;
+            pillar(id: string, textures: import("./Constructors/Voxel/Classes/Cube/PillarCube.constructor.js").PillarCubeVoxelConstructorData): import("./Constructors/Voxel/Classes/Cube/PillarCube.constructor.js").PillarCubeVoxelConstructor;
+        };
+        halfCube: {
+            mod(id: string, textures: import("../Textures/Constructor.types.js").ConstructorTextureData[]): import("./Constructors/Voxel/Classes/HalfCube/ModHalfCube.constructor.js").ModHalfCubeVoxelConstructor;
+            simple(id: string, textures: import("./Constructors/Voxel/Classes/HalfCube/SimpleHalfCube.constructor.js").SimpleHalfCubeVoxelConstructor["textureData"]): import("./Constructors/Voxel/Classes/HalfCube/SimpleHalfCube.constructor.js").SimpleHalfCubeVoxelConstructor;
+        };
+        stair: {
+            mod(id: string, textures: import("../Textures/Constructor.types.js").ConstructorTextureData[]): import("./Constructors/Voxel/Classes/Stair/ModStair.constructor.js").ModStairVoxelConstructor;
+            simple(id: string, texture: import("../Textures/Constructor.types.js").ConstructorTextureData): import("./Constructors/Voxel/Classes/Stair/SimpleStair.constructor.js").SimpleStairVoxelConstructor;
+        };
+        panel: {
+            simple(id: string, texture: import("../Textures/Constructor.types.js").ConstructorTextureData): import("./Constructors/Voxel/Classes/Panel/SimplePanel.constructor.js").SimplePanelVoxelConstructor;
+        };
+        crossedPanel: {
+            simple(id: string, texture: import("../Textures/Constructor.types.js").ConstructorTextureData): import("./Constructors/Voxel/Classes/Panel/SimpleCrossedPanel.constructor.js").SimpleCrossedPanelVoxelConstructor;
+        };
+        liquid: {
+            simple(id: string, textures: [import("../Textures/Constructor.types.js").ConstructorTextureData, import("../Textures/Constructor.types.js").ConstructorTextureData]): import("./Constructors/Voxel/Classes/Liquid/SimpleLiquid.constructor.js").SimpleLiquidConstructor;
+        };
+    };
+    constructors: typeof VoxelConstructorsRegister;
+    textureManager: {
+        textureDataHasBeenSet: boolean;
+        data: import("../Textures/Texture.types.js").TextureTypeUVMap;
+        getTextureUV(data: import("../Textures/Constructor.types.js").ConstructorTextureData, overlay?: boolean): number;
+        setTextureIndex(data: import("../Textures/Texture.types.js").TextureTypeUVMap): void;
+        releaseTextureData(): void;
+        isReady(): boolean;
+    };
+    chunkProcessor: ChunkProcessor;
+    nodes: {
+        builders: Map<string, import("./Meshers/Classes/Mesher.js").Mesher>;
+        registerBuilder(builder: import("./Meshers/Classes/Mesher.js").Mesher): void;
+        buildNode(data: BuildNodeMesh): [import("./Tasks/BuidlerTasks.types.js").SetNodeMesh, ArrayBuffer[]] | false;
+    };
+    overrides: typeof OverrideManager;
+    renderedSubstances: typeof RenderedSubstances;
+    shapes: typeof VoxelShapeManager;
+    observers: {
+        texturesRegistered: Observable<{
+            textureDataHasBeenSet: boolean;
+            data: import("../Textures/Texture.types.js").TextureTypeUVMap;
+            getTextureUV(data: import("../Textures/Constructor.types.js").ConstructorTextureData, overlay?: boolean): number;
+            setTextureIndex(data: import("../Textures/Texture.types.js").TextureTypeUVMap): void;
+            releaseTextureData(): void;
+            isReady(): boolean;
+        }>;
+    };
+    constructor(data: DVEMesherInitData);
+    init(): void;
+    meshChunk(location: LocationData, LOD?: number, priority?: number): boolean;
+}

package/Mesher/Mesher.js

@@ -0,0 +1,62 @@
+import { VoxelConstructorsRegister } from "./Constructors/Voxel/VoxelConstructorsRegister.js";
+import { ChunkProcessor } from "./Processors/ChunkProcessor.js";
+import { OverrideManager } from "./Rules/Overrides/OverridesManager.js";
+import { RenderedSubstances } from "./Rules/RenderedSubstances.js";
+import { TextureRegister } from "../Textures/TextureRegister.js";
+import { MesherManager } from "./Meshers/MesherManager.js";
+import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor.js";
+import { SubstanceRules } from "./Rules/SubstanceRules.js";
+import { VoxelShapeManager } from "./Shapes/VoxelShapeManager.js";
+import { Observable } from "@amodx/core/Observers";
+export class DVEMesher {
+    static observers = {
+        texturesRegistered: new Observable(),
+    };
+    static instance;
+    static get defaults() {
+        return VoxelConstructorsRegister.defaults;
+    }
+    constructors = VoxelConstructorsRegister;
+    textureManager = TextureRegister;
+    chunkProcessor = new ChunkProcessor();
+    nodes = MesherManager;
+    overrides = OverrideManager;
+    renderedSubstances = RenderedSubstances;
+    shapes = VoxelShapeManager;
+    observers = DVEMesher.observers;
+    constructor(data) {
+        if (!DVEMesher.instance)
+            DVEMesher.instance = this;
+        this.constructors.registerVoxel(data.constructors);
+        return DVEMesher.instance;
+    }
+    init() {
+        this.shapes.init();
+        DivineVoxelEngineConstructor.instance.TC.registerTasks("sync-texuture-index", (data) => {
+            this.textureManager.setTextureIndex(data);
+            this.constructors.constructors.forEach((_) => {
+                try {
+                    _.onTexturesRegistered(this.textureManager);
+                }
+                catch (error) {
+                    console.log("error when loading textures into constructors");
+                    console.log(_);
+                    console.error(error);
+                }
+            });
+            this.observers.texturesRegistered.notify(this.textureManager);
+            this.textureManager.releaseTextureData();
+            SubstanceRules.buildRules();
+        });
+        DivineVoxelEngineConstructor.instance.TC.registerTasks("build-node-mesh", (data, onDone) => {
+            const nodeData = this.nodes.buildNode(data);
+            if (!nodeData)
+                return onDone ? onDone(false) : 0;
+            onDone ? onDone(nodeData[0], nodeData[1]) : 0;
+        }, "deferred");
+    }
+    meshChunk(location, LOD = 1, priority = 0) {
+        this.chunkProcessor.build(location);
+        return true;
+    }
+}

package/Mesher/Meshers/Classes/Mesher.d.ts

@@ -0,0 +1,6 @@
+import { BuildNodeMesh, SetNodeMesh } from "../../Tasks/BuidlerTasks.types";
+export declare abstract class Mesher {
+    id: string;
+    constructor(id: string);
+    abstract build(data: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
+}

package/Mesher/Meshers/Classes/Mesher.js

@@ -0,0 +1,6 @@
+export class Mesher {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+}

package/Mesher/Meshers/MesherManager.d.ts

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

package/Mesher/Meshers/MesherManager.js

@@ -0,0 +1,16 @@
+import { TextureBuilder } from "./Meshers/TextureMesher.js";
+import { VoxelBuilder } from "./Meshers/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/Meshers/TextureMesher.d.ts

@@ -0,0 +1,13 @@
+import { Mesher } from "../Classes/Mesher.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 extends Mesher {
+    build(buildTask: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]];
+}
+export declare const TextureBuilder: TXTBuilderBase;
+export {};

package/Mesher/Meshers/Meshers/TextureMesher.js

@@ -0,0 +1,186 @@
+import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools.js";
+import { Mesher } from "../Classes/Mesher.js";
+import { BinaryNumberTypes } from "@amodx/binary";
+import { Quad } from "@amodx/meshing/Classes/Quad.js";
+import { QuadVerticies } from "@amodx/meshing/Geometry.types.js";
+import { GeometryBuilder } from "@amodx/meshing";
+import { Flat2DIndex, Vector3Like } from "@amodx/math";
+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.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
+tool.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 extends Mesher {
+    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.getAttribute("uv");
+        const textureIndex = tool.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];
+                }
+            }
+        }
+        const [attributes, transfers] = tool.getAllAttributes();
+        for (const [type, data] of attributes) {
+            if (type == "position") {
+                for (let i = 0; i < data.length; i += 3) {
+                    data[i] -= 0.5;
+                    data[i + 1] -= 0.5;
+                    data[i + 2];
+                }
+            }
+        }
+        tool.resetVars();
+        tool.resetAttributes();
+        return [[location, attributes], transfers];
+    }
+}
+export const TextureBuilder = new TXTBuilderBase("#dve_node_texture");

package/Mesher/Meshers/Meshers/VoxelMesher.d.ts

@@ -0,0 +1,11 @@
+import { Mesher } from "../Classes/Mesher.js";
+import { BuilderDataTool } from "../../Tools/BuilderDataTool.js";
+import { BuildNodeMesh, SetNodeMesh } from "../../Tasks/BuidlerTasks.types.js";
+declare class VoxelBuilderBase extends Mesher {
+    id: string;
+    dataTool: BuilderDataTool;
+    constructor(id: string);
+    build([location, type, rawVoxelData]: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
+}
+export declare const VoxelBuilder: VoxelBuilderBase;
+export {};

package/Mesher/Meshers/Meshers/VoxelMesher.js

@@ -0,0 +1,47 @@
+import { Mesher } from "../Classes/Mesher.js";
+import { BuilderDataTool } from "../../Tools/BuilderDataTool.js";
+import { RenderedSubstances } from "../../Rules/RenderedSubstances.js";
+import { ShapeTool } from "../../Shapes/ShapeTool.js";
+class VoxelBuilderBase extends Mesher {
+    id;
+    dataTool = new BuilderDataTool();
+    constructor(id) {
+        super(id);
+        this.id = id;
+        this.dataTool.setMode(BuilderDataTool.Modes.VOXEL_DATA);
+    }
+    build([location, type, rawVoxelData]) {
+        if (!this.dataTool.loadInRaw(rawVoxelData).isRenderable())
+            return false;
+        const constructor = this.dataTool.getConstructor();
+        const mesher = RenderedSubstances.meshers.get(this.dataTool.getSubstnaceData().getRendered());
+        if (!mesher || !constructor)
+            return false;
+        ShapeTool.origin.x = 0;
+        ShapeTool.origin.y = 0;
+        ShapeTool.origin.z = 0;
+        mesher.resetAll();
+        mesher.voxel
+            .loadInRaw(rawVoxelData)
+            .setMode(BuilderDataTool.Modes.VOXEL_DATA);
+        mesher.nVoxel
+            .loadInRaw(rawVoxelData)
+            .setMode(BuilderDataTool.Modes.VOXEL_DATA);
+        ShapeTool.setMesher(mesher);
+        constructor.process(mesher);
+        mesher.resetVars();
+        const [attributes, buffers] = mesher.getAllAttributes();
+        for (const [type, data] of attributes) {
+            if (type == "position") {
+                for (let i = 0; i < data.length; i++) {
+                    data[i] -= 0.5;
+                }
+            }
+        }
+        mesher.voxel.setMode(BuilderDataTool.Modes.WORLD);
+        mesher.nVoxel.setMode(BuilderDataTool.Modes.WORLD);
+        mesher.resetAttributes();
+        return [[location, attributes], buffers];
+    }
+}
+export const VoxelBuilder = new VoxelBuilderBase("#dve_node_voxel");

package/Mesher/Processors/ChunkProcessor.d.ts

@@ -0,0 +1,9 @@
+import type { LocationData } from "../../Math/index.js";
+import { HeightMapTool } from "../../Tools/Data/WorldData/HeightMapTool.js";
+import { BuilderDataTool } from "../Tools/BuilderDataTool.js";
+export declare class ChunkProcessor {
+    mDataTool: BuilderDataTool;
+    heightMapTool: HeightMapTool;
+    _process(x: number, y: number, z: number, doSecondCheck?: boolean): boolean;
+    build(location: LocationData, priority?: number): void;
+}

package/Mesher/Processors/ChunkProcessor.js

@@ -0,0 +1,79 @@
+//objects
+import { RenderedSubstances } from "../Rules/RenderedSubstances.js";
+import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
+//data
+import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
+//tools
+import { HeightMapTool } from "../../Tools/Data/WorldData/HeightMapTool.js";
+import { BuilderDataTool } from "../Tools/BuilderDataTool.js";
+import { ShapeTool } from "../Shapes/ShapeTool.js";
+import { VoxelGeometryLookUp } from "../../VoxelModels/Constructor/VoxelGeometryLookUp.js";
+export class ChunkProcessor {
+    mDataTool = new BuilderDataTool();
+    heightMapTool = new HeightMapTool();
+    _process(x, y, z, doSecondCheck = false) {
+        if (!this.mDataTool.loadInAt(x, y, z))
+            return false;
+        if (!this.mDataTool.isRenderable())
+            return false;
+        let hasVoxel = false;
+        this.mDataTool.setSecondary(doSecondCheck);
+        if (!doSecondCheck) {
+            if (this.mDataTool.hasSecondaryVoxel()) {
+                hasVoxel = this._process(x, y, z, true);
+            }
+        }
+        const constructor = this.mDataTool.getConstructor();
+        const mesher = RenderedSubstances.meshers.get(this.mDataTool.getSubstnaceData().getRendered());
+        if (!mesher || !constructor) {
+            throw new Error(`Could not find mesh or constructor ${this.mDataTool.getId()} | ${this.mDataTool.getName()} | ${this.mDataTool.getConstructor()?.id}`);
+        }
+        const voxelPOS = WorldSpaces.voxel.getPositionXYZ(x, y, z);
+        ShapeTool.origin.x = voxelPOS.x;
+        ShapeTool.origin.y = voxelPOS.y;
+        ShapeTool.origin.z = voxelPOS.z;
+        mesher.voxel.loadInAt(x, y, z);
+        mesher.nVoxel.loadInAt(x, y, z);
+        ShapeTool.setMesher(mesher);
+        constructor.process(mesher);
+        mesher.resetVars();
+        return true;
+    }
+    build(location, priority = 0) {
+        this.heightMapTool.chunk.loadInAtLocation(location);
+        this.mDataTool.setDimension(location[0]);
+        RenderedSubstances.setDimension(location[0]);
+        const [dimension, cx, cy, cz] = location;
+        let [minY, maxY] = this.heightMapTool.chunk.getMinMax();
+        if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
+            return;
+        VoxelGeometryLookUp.start(dimension, location[1], location[2], location[3]);
+        for (let y = minY; y <= maxY; y++) {
+            let foundVoxels = false;
+            for (let x = 0; x < WorldSpaces.chunk._bounds.x; x++) {
+                for (let z = 0; z < WorldSpaces.chunk._bounds.z; z++) {
+                    if (this._process(x + cx, y + cy, z + cz)) {
+                        foundVoxels = true;
+                    }
+                }
+            }
+            this.heightMapTool.chunk.setY(y).setHasVoxels(foundVoxels);
+            this.heightMapTool.chunk.setY(y).setDirty(false);
+        }
+        VoxelGeometryLookUp.stop();
+        const chunks = [location, [], priority];
+        const trasnfers = [];
+        for (const [substance, mesher] of RenderedSubstances.meshers) {
+            if (mesher.positions.length == 0) {
+                chunks[1].push([substance, false]);
+                mesher.resetAll();
+                continue;
+            }
+            const [attributes, buffers] = mesher.getAllAttributes();
+            trasnfers.push(...buffers);
+            chunks[1].push([substance, [location, attributes]]);
+            mesher.resetAll();
+        }
+        DivineVoxelEngineConstructor.instance.threads.parent.runTasks("set-chunk", chunks, trasnfers);
+    }
+}

package/Mesher/Processors/TemplateProcessor.d.ts

@@ -0,0 +1,16 @@
+import type { LocationData } from ".../../Math/index.js";
+import { Flat3DIndex } from "@amodx/math/Volumes/Indexing/Flat3DIndex.js";
+import { Vec3Array } from "@amodx/math";
+export declare const TemplateProcessor: {
+    relative: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    nLocation: LocationData;
+    _states: {
+        foundVoxel: boolean;
+    };
+    _process(index: number, template: Uint32Array): void;
+    build(location: LocationData, template: Uint32Array, startIndex: Vec3Array, templateIndex: Flat3DIndex): void;
+};

package/Mesher/Processors/TemplateProcessor.js

@@ -0,0 +1,71 @@
+//objects
+import { RenderedSubstances } from "../Rules/RenderedSubstances.js";
+import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
+//tools
+import { BuilderDataTool } from "../Tools/BuilderDataTool.js";
+import { ShapeTool } from "../Shapes/ShapeTool.js";
+const mDataTool = new BuilderDataTool();
+export const TemplateProcessor = {
+    relative: { x: 0, y: 0, z: 0 },
+    nLocation: ["main", 0, 0, 0],
+    _states: {
+        foundVoxel: false,
+    },
+    _process(index, template) {
+        const mainId = template[index] & 0xffff;
+        if (!mainId || !mDataTool.loadInAtLocation(this.nLocation))
+            return;
+        const constructor = mDataTool.getConstructor();
+        const mesher = RenderedSubstances.meshers.get(mDataTool.getSubstnaceData().getRendered());
+        if (!mesher || !constructor)
+            return;
+        mesher.template.setActive(true);
+        mesher.template.load(template, index);
+        mesher.voxel.loadInAtLocation(this.nLocation);
+        mesher.nVoxel.loadInAtLocation(this.nLocation);
+        ShapeTool.setMesher(mesher);
+        constructor.process(mesher);
+        mesher.resetVars();
+        mesher.template.setActive(false);
+    },
+    build(location, template, startIndex, templateIndex) {
+        mDataTool.setDimension(location[0]);
+        const [dimension, cx, cy, cz] = location;
+        this.nLocation[0] = dimension;
+        let [six, siy, siz] = startIndex;
+        let ix = six, iy = siy, iz = siz;
+        const curosr = new Int32Array(3);
+        for (let x = cx; x < cx + 16; x++) {
+            iz = siz;
+            for (let z = cz; z < cz + 16; z++) {
+                iy = siy;
+                for (let y = cy; y < cy + 16; y++) {
+                    this.nLocation[1] = x;
+                    this.nLocation[2] = y;
+                    this.nLocation[3] = z;
+                    curosr[0] = ix;
+                    curosr[1] = iy;
+                    curosr[2] = iz;
+                    //   this._process(templateIndex.getIndex(curosr) * 17, template);
+                    iy++;
+                }
+                iz++;
+            }
+            ix++;
+        }
+        const chunks = [location, [], 0];
+        const trasnfers = [];
+        for (const [substance, mesher] of RenderedSubstances.meshers) {
+            if (mesher.getAttribute("position").length == 0) {
+                chunks[1].push([substance, false]);
+                mesher.resetAll();
+                continue;
+            }
+            const [attributes, buffers] = mesher.getAllAttributes();
+            trasnfers.push(...buffers);
+            chunks[1].push([substance, [location, attributes]]);
+            mesher.resetAll();
+        }
+        DivineVoxelEngineConstructor.instance.threads.parent.runTasks("set-chunk", chunks, trasnfers);
+    },
+};

package/Mesher/Rules/Overrides/OverrideBase.d.ts

@@ -0,0 +1,8 @@
+import { FaceDataOverride } from "../../Types";
+type Run = (data: FaceDataOverride) => boolean;
+export declare class OverrideBase {
+    voxels: Run[][];
+    register(voxel: number, override: number, run: Run): void;
+    run(voxel: number, override: number, data: FaceDataOverride): boolean;
+}
+export {};

package/Mesher/Rules/Overrides/OverrideBase.js

@@ -0,0 +1,20 @@
+export class OverrideBase {
+    voxels = [];
+    register(voxel, override, run) {
+        let voxelRules = this.voxels[voxel];
+        if (!voxelRules) {
+            voxelRules = [];
+            this.voxels[voxel] = voxelRules;
+        }
+        voxelRules[override] = run;
+    }
+    run(voxel, override, data) {
+        const voxelRules = this.voxels[voxel];
+        if (!voxelRules)
+            return data.default;
+        const secondRule = voxelRules[override];
+        if (!secondRule)
+            return data.default;
+        return secondRule(data);
+    }
+}