@divinevoxel/vlox 0.0.2 → 0.0.4

package/Interfaces/Anaylzer/DVEAnaylzer.js

@@ -1,2 +0,0 @@
-export class DVEAnaylzer {
-}

package/Interfaces/Classes/ThreadState.d.ts

@@ -1,7 +0,0 @@
-import { ThreadManager } from "./ThreadManager";
-export declare abstract class ThreadState<Threads extends ThreadManager = ThreadManager> {
-    threads: Threads;
-    settingsSynced: boolean;
-    constructor(threads: Threads);
-    abstract isReady(): boolean;
-}

package/Interfaces/Classes/ThreadState.js

@@ -1,7 +0,0 @@
-export class ThreadState {
-    threads;
-    settingsSynced = false;
-    constructor(threads) {
-        this.threads = threads;
-    }
-}

package/Interfaces/Data/DataManager.d.ts

@@ -1,13 +0,0 @@
-import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
-import { WorldBounds } from "../../Data/World/WorldBounds";
-import { VoxelStruct } from "../../Data/Voxel/VoxelStruct";
-import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct";
-export declare abstract class DataManager {
-    worldBounds: typeof WorldBounds;
-    spaces: import("../../Math/Spaces/VoxelSpaces").VoxelSpaces;
-    mapped: typeof MappedDataRegister;
-    tags: {
-        voxels: typeof VoxelStruct;
-        substances: typeof SubstanceStruct;
-    };
-}

package/Interfaces/Data/DataManager.js

@@ -1,14 +0,0 @@
-import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
-import { WorldBounds } from "../../Data/World/WorldBounds";
-import { WorldSpaces } from "../../Data/World/WorldSpaces";
-import { VoxelStruct } from "../../Data/Voxel/VoxelStruct";
-import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct";
-export class DataManager {
-    worldBounds = WorldBounds;
-    spaces = WorldSpaces;
-    mapped = MappedDataRegister;
-    tags = {
-        voxels: VoxelStruct,
-        substances: SubstanceStruct,
-    };
-}

package/Interfaces/Data/RemoteDataSyncNode.d.ts

@@ -1,16 +0,0 @@
-import type { VoxelDataSync, PaletteSyncData, RegisterStringMapSync } from "Types/DataSync.types.js";
-import { BinaryStructData } from "@amodx/binary/";
-export declare abstract class RemoteDataSyncNode {
-    maps: {
-        strings: import("@amodx/threads/").DataSync<RegisterStringMapSync, void>;
-        objects: import("@amodx/threads/").DataSync<RegisterStringMapSync, void>;
-    };
-    palettes: {
-        voxel: import("@amodx/threads/").DataSync<PaletteSyncData, any>;
-        substance: import("@amodx/threads/").DataSync<PaletteSyncData, any>;
-    };
-    tags: {
-        voxel: import("@amodx/threads/").DataSync<VoxelDataSync, any>;
-        substance: import("@amodx/threads/").DataSync<BinaryStructData, any>;
-    };
-}

package/Interfaces/Data/RemoteDataSyncNode.js

@@ -1,36 +0,0 @@
-//objects
-import { Threads } from "@amodx/threads/";
-import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct.js";
-import { DataSyncIds } from "../Common/DataSyncIds.js";
-import { MappedDataRegister } from "../../Data/Register/MappedDataRegister.js";
-import { VoxelPalette } from "../../Data/Voxel/VoxelPalette.js";
-import { SubstancePaletteReader } from "../../Data/Substance/SubstancePalette.js";
-import { VoxelStruct } from "../../Data/Voxel/VoxelStruct.js";
-export class RemoteDataSyncNode {
-    maps = {
-        strings: Threads.onDataSync(DataSyncIds.RegisterStringMap, (data) => {
-            MappedDataRegister.stringMaps.sync(data[0], data[1], data[2]);
-        }),
-        objects: Threads.onDataSync(DataSyncIds.RegisterObjectMap, (data) => {
-            MappedDataRegister.objectMaps.sync(data[0], data[1], data[2]);
-        }),
-    };
-    palettes = {
-        voxel: Threads.onDataSync(DataSyncIds.VoxelPalette, ([palette, map, nameToId, idToName]) => {
-            VoxelPalette.setVoxelIdPalette(palette, map);
-            VoxelPalette.setVoxelNamePalette(nameToId, idToName);
-        }),
-        substance: Threads.onDataSync(DataSyncIds.SubstancePalette, ([palette, map]) => {
-            SubstancePaletteReader.setPalette(palette, map);
-        }),
-    };
-    tags = {
-        voxel: Threads.onDataSync(DataSyncIds.VoxelTags, (data) => {
-            VoxelStruct.init(data[0]);
-            VoxelStruct.sync(new Uint16Array(data[1]));
-        }),
-        substance: Threads.onDataSync(DataSyncIds.SubstanceTags, (data) => {
-            SubstanceStruct.init(data);
-        }),
-    };
-}

package/Interfaces/Render/DVEFOManager.d.ts

@@ -1,7 +0,0 @@
-import { URIScene } from "@amodx/uri/Scenes/URIScene";
-import { URINode } from "@amodx/uri/Meshes/URINode";
-export declare abstract class DVEFOManager {
-    scene: URIScene;
-    constructor(scene: URIScene);
-    abstract getActiveNode(): URINode | null;
-}

package/Interfaces/Render/DVEFOManager.js

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

package/Interfaces/Render/DVEMeshCuller.d.ts

@@ -1,7 +0,0 @@
-import { URIScene } from "@amodx/uri/Scenes/URIScene";
-import { DVEFOManager } from "./DVEFOManager";
-export declare abstract class DVEMeshCuller {
-    scene: URIScene;
-    foManager: DVEFOManager;
-    constructor(scene: URIScene, foManager: DVEFOManager);
-}

package/Interfaces/Render/DVEMeshCuller.js

@@ -1,8 +0,0 @@
-export class DVEMeshCuller {
-    scene;
-    foManager;
-    constructor(scene, foManager) {
-        this.scene = scene;
-        this.foManager = foManager;
-    }
-}

package/Interfaces/Render/DVERenderer.d.ts

@@ -1,14 +0,0 @@
-import { URIEngine } from "@amodx/uri/Engine/URIEngine.js";
-import { URIScene } from "@amodx/uri/Scenes/URIScene.js";
-import { DVEMeshCuller } from "./DVEMeshCuller.js";
-import { DVEFOManager } from "./DVEFOManager.js";
-import { DVENodeManager } from "./Nodes/DVENodeManager.js";
-import { DivineVoxelEngineRender } from "../../Contexts/Render/DivineVoxelEngineRender.js";
-export declare abstract class DVERenderer {
-    abstract engine: URIEngine;
-    abstract scene: URIScene;
-    abstract foManager: DVEFOManager;
-    abstract meshCuller: DVEMeshCuller;
-    abstract nodes: DVENodeManager;
-    abstract init(dver: DivineVoxelEngineRender): Promise<void>;
-}

package/Interfaces/Render/Nodes/DVENodeManager.d.ts

@@ -1,6 +0,0 @@
-import { DVENodeMaterialManager } from "./Materials/DVENodeMaterialManager";
-import { DVENodeMeshManager } from "./Meshes/DVENodeMeshManager";
-export declare abstract class DVENodeManager {
-    abstract materials: DVENodeMaterialManager;
-    abstract meshes: DVENodeMeshManager;
-}

package/Interfaces/Render/Nodes/DVENodeManager.js

@@ -1,2 +0,0 @@
-export class DVENodeManager {
-}

package/Interfaces/Render/Nodes/Materials/DVENodeMaterialManager.d.ts

@@ -1,5 +0,0 @@
-import { URIMaterial } from "@amodx/uri/Materials/URIMaterial";
-export declare abstract class DVENodeMaterialManager {
-    abstract get(id: string): URIMaterial;
-    abstract register(id: string, material: URIMaterial): void;
-}

package/Interfaces/Render/Nodes/Materials/DVENodeMaterialManager.js

@@ -1,2 +0,0 @@
-export class DVENodeMaterialManager {
-}

package/Interfaces/Render/Nodes/Meshes/DVENodeMesh.d.ts

@@ -1,13 +0,0 @@
-import type { EngineSettingsData } from "Types/EngineSettings.types.js";
-import { URIMesh } from "@amodx/uri/Meshes/URIMesh.js";
-import { NodeMeshData, DVENodeMeshAttributes } from "../DVERenderNode.types";
-import { Vec3Array } from "@amodx/math";
-export declare abstract class DVENodeMesh {
-    data: NodeMeshData;
-    constructor(data: NodeMeshData);
-    abstract createMesh(position: Vec3Array, data: DVENodeMeshAttributes): URIMesh;
-    abstract returnMesh(mesh: URIMesh): void;
-    abstract updateVertexData(position: Vec3Array, data: DVENodeMeshAttributes, mesh: URIMesh): void;
-    abstract syncSettings(settings: EngineSettingsData): void;
-    abstract _clearCached(mesh: URIMesh): void;
-}

package/Interfaces/Render/Nodes/Meshes/DVENodeMesh.js

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

package/Interfaces/Render/Nodes/Meshes/DVENodeMeshManager.d.ts

@@ -1,5 +0,0 @@
-import { DVENodeMesh } from "./DVENodeMesh";
-export declare abstract class DVENodeMeshManager {
-    abstract get(id: string): DVENodeMesh;
-    abstract register(id: string, mesh: DVENodeMesh): void;
-}

package/Interfaces/Render/Nodes/Meshes/DVENodeMeshManager.js

@@ -1,2 +0,0 @@
-export class DVENodeMeshManager {
-}

package/Mesher/Calc/Flow/FlowGradient.d.ts

@@ -1,5 +0,0 @@
-import type { VoxelMesherDataTool } from "../../Tools/VoxelMesherDataTool";
-export declare const FlowGradient: {
-    getLevel(tool: VoxelMesherDataTool, x: number, y: number, z: number): number;
-    calculate(tool: VoxelMesherDataTool): void;
-};

package/Mesher/Calc/Light/LightGradient.d.ts

@@ -1,13 +0,0 @@
-import type { VoxelMesherDataTool } from "../../Tools/VoxelMesherDataTool";
-import { VoxelFaces } from "../../../Math";
-import { Vector3Like } from "@amodx/math";
-export declare const LightGradient: {
-    tool: VoxelMesherDataTool;
-    settings: {
-        doAO: boolean;
-        doRGB: boolean;
-        doSun: boolean;
-    };
-    aoOffset: Vector3Like;
-    calculate(face: VoxelFaces, tool: VoxelMesherDataTool, ignoreAO?: boolean): void;
-};

package/Mesher/Calc/Light/LightGradient.js

@@ -1,255 +0,0 @@
-import { OverrideManager } from "../../Rules/Overrides/OverridesManager.js";
-import { LightData } from "../../../Data/LightData";
-import { QuadScalarVertexData, QuadVec3ArrayVertexData } from "@amodx/meshing/Classes/QuadVertexData";
-import { SubstanceRules } from "../../Rules/SubstanceRules.js";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types";
-import { VoxelFaces, VoxelFaceDirections } from "../../../Math";
-import { Vector3Like } from "@amodx/math";
-import { GradientCheckSets } from "../CalcConstants";
-const LD = LightData;
-const LightValue = new QuadScalarVertexData();
-const AOValue = new QuadScalarVertexData();
-const AOGeometryValues = new QuadVec3ArrayVertexData();
-const isMax = (num, v1, v2) => {
-    return num >= v1 && num >= v2;
-};
-const isAllEqual = (num, v1, v2, v3) => {
-    return num == v1 && v1 == v2 && v2 == v3;
-};
-const shouldSunFlip = (face) => {
-    const upRight = LD.getS(LightValue.vertices[QuadVerticies.TopRight]);
-    const upLeft = LD.getS(LightValue.vertices[QuadVerticies.TopLeft]);
-    const downLeft = LD.getS(LightValue.vertices[QuadVerticies.BottomLeft]);
-    const downRight = LD.getS(LightValue.vertices[QuadVerticies.BottomRight]);
-    if (isAllEqual(upRight, upLeft, downLeft, downRight))
-        return false;
-    const t1 = downLeft > upLeft && downLeft > upRight && downLeft > downRight;
-    const t2 = upRight > upLeft && upRight > downLeft && upRight > downRight;
-    const t3 = upLeft < downLeft && upLeft < upRight && upLeft < downRight;
-    const t4 = downRight < upLeft && downRight < upRight && downRight < upLeft;
-    if (t1 && !t2)
-        return true;
-    if (t2 && !t1)
-        return true;
-    if (t3)
-        return true;
-    if (t4)
-        return true;
-    return false;
-};
-const shouldRGBFlip = (face) => {
-    const upRight = LD.getRGB(LightValue.vertices[QuadVerticies.TopRight]);
-    const upLeft = LD.getRGB(LightValue.vertices[QuadVerticies.TopLeft]);
-    const downLeft = LD.getRGB(LightValue.vertices[QuadVerticies.BottomLeft]);
-    const downRight = LD.getRGB(LightValue.vertices[QuadVerticies.BottomRight]);
-    if (isAllEqual(upRight, upLeft, downLeft, downRight))
-        return false;
-    const t1 = downLeft > upLeft && downLeft > upRight && downLeft > downRight;
-    const t2 = upRight > upLeft && upRight > downLeft && upRight > downRight;
-    const t3 = upLeft < downLeft && upLeft < upRight && upLeft < downRight;
-    const t4 = downRight < upLeft && downRight < upRight && downRight < upLeft;
-    if (t1 && !t2)
-        return true;
-    if (t2 && !t1)
-        return true;
-    if (t3)
-        return true;
-    if (t4)
-        return true;
-    return false;
-};
-const shouldAOFlip = (face) => {
-    if (states.ignoreAO)
-        return false;
-    LightGradient.tool.faceDataOverride.face = face;
-    LightGradient.tool.faceDataOverride.default = false;
-    if (OverrideManager.AOFlipFace.run(LightGradient.tool.voxel.getShapeId(), OverrideManager.ANY, LightGradient.tool.faceDataOverride)) {
-        return false;
-    }
-    const upRight = AOValue.vertices[QuadVerticies.TopRight];
-    const upLeft = AOValue.vertices[QuadVerticies.TopLeft];
-    const downRight = AOValue.vertices[QuadVerticies.BottomRight];
-    const downLeft = AOValue.vertices[QuadVerticies.BottomLeft];
-    if (isAllEqual(upRight, upLeft, downLeft, downRight))
-        return false;
-    const t1 = isMax(upRight, upLeft, downRight);
-    const t2 = isMax(downLeft, upLeft, downRight);
-    if (t1 || t2)
-        return true;
-    return false;
-};
-const flipCheck = (face) => {
-    if (shouldAOFlip(face))
-        return true;
-    if (shouldRGBFlip(face))
-        return true;
-    return shouldSunFlip(face);
-};
-/**
- *
-2       1
-|    /  |
-|   /   |
-|  /    |
-| /     |
-3       4
-
-
- */
-const states = { ignoreAO: false };
-const newRGBValues = [];
-const RGBValues = { r: 0, g: 0, b: 0 };
-const sunValues = { s: 0 };
-const nlValues = { s: 0, r: 0, g: 0, b: 0 };
-const AOValues = { a: 0 };
-export const LightGradient = {
-    tool: {},
-    settings: {
-        doAO: true,
-        doRGB: true,
-        doSun: true,
-    },
-    aoOffset: Vector3Like.Create(),
-    calculate(face, tool, ignoreAO) {
-        tool.setFaceFlipped(false).getWorldLight().setAll(0);
-        tool.getWorldAO().setAll(0);
-        this.tool = tool;
-        const voxelSubstance = SubstanceRules.getSubstanceParent(tool.voxel.getSubstance());
-        const isLightSource = tool.voxel.isLightSource();
-        let light = tool.voxel.getLight();
-        let aoOverRide = -1;
-        AOValue.setAll(1);
-        if (this.settings.doAO && !ignoreAO) {
-            states.ignoreAO = false;
-        }
-        else {
-            states.ignoreAO = true;
-        }
-        let baseAO = 0;
-        const faceNormal = VoxelFaceDirections[face];
-        tool.nVoxel.loadInAt(tool.voxel.x + faceNormal[0], tool.voxel.y + faceNormal[1], tool.voxel.z + faceNormal[2]);
-        light = tool.nVoxel.getLight();
-        if (light < 0) {
-            if (tool.voxel.getLight() >= 0) {
-                light = tool.voxel.getLight();
-            }
-            else {
-                light = 0;
-            }
-        }
-        if (face == VoxelFaces.Up) {
-            if (tool.nVoxel.isRenderable() && !tool.nVoxel.isLightSource()) {
-                tool.faceDataOverride.face = face;
-                tool.faceDataOverride.default = false;
-                if (OverrideManager.DarkenFaceUnderneath.run(tool.nVoxel.getShapeId(), OverrideManager.ANY, tool.faceDataOverride)) {
-                    aoOverRide = 1;
-                }
-            }
-        }
-        for (let vertex = 0; vertex < 4; vertex++) {
-            const checkSet = GradientCheckSets[face][vertex];
-            if (this.settings.doRGB || this.settings.doSun) {
-                const values = LD.getLightValues(light);
-                if (this.settings.doSun) {
-                    sunValues.s = values[0];
-                }
-                if (this.settings.doRGB) {
-                    RGBValues.r = values[1];
-                    RGBValues.g = values[2];
-                    RGBValues.b = values[3];
-                }
-            }
-            AOValues.a = 0;
-            let checkSetIndex = 0;
-            for (let i = 0; i < 9; i += 3) {
-                if (this.settings.doRGB || this.settings.doSun) {
-                    if (!tool.nVoxel.loadInAt(checkSet[i] + tool.voxel.x, checkSet[i + 1] + tool.voxel.y, checkSet[i + 2] + tool.voxel.z))
-                        continue;
-                    const nl = tool.nVoxel.getLight();
-                    if (nl >= 0) {
-                        const values = LD.getLightValues(nl);
-                        nlValues.s = values[0];
-                        nlValues.r = values[1];
-                        nlValues.g = values[2];
-                        nlValues.b = values[3];
-                        if (this.settings.doRGB) {
-                            if (LD.removeS(nl)) {
-                                if (nlValues.r > RGBValues.r && RGBValues.r < 15) {
-                                    RGBValues.r = nlValues.r;
-                                }
-                                if (nlValues.g > RGBValues.g && RGBValues.g < 15) {
-                                    RGBValues.g = nlValues.g;
-                                }
-                                if (nlValues.b > RGBValues.b && RGBValues.b < 15) {
-                                    RGBValues.b = nlValues.b;
-                                }
-                            }
-                        }
-                        if (this.settings.doSun) {
-                            if (LD.getS(nl)) {
-                                if (sunValues.s < nlValues.s && sunValues.s < 15) {
-                                    sunValues.s = nlValues.s;
-                                }
-                            }
-                        }
-                    }
-                }
-                /*
-            Do AO
-            */
-                if (!states.ignoreAO) {
-                    if (!tool.nVoxel.loadInAt(tool.nVoxel.x + this.aoOffset.x, tool.nVoxel.y + this.aoOffset.y, tool.nVoxel.z + this.aoOffset.z))
-                        continue;
-                    if (aoOverRide > 0) {
-                        AOValues.a = aoOverRide;
-                    }
-                    else if (!tool.nVoxel.isRenderable()) {
-                    }
-                    else {
-                        const neighborVoxelSubstance = SubstanceRules.getSubstanceParent(tool.nVoxel.getSubstance());
-                        const neightLightSource = tool.nVoxel.isLightSource();
-                        let finalResult = true;
-                        if (neighborVoxelSubstance != voxelSubstance) {
-                            finalResult = false;
-                        }
-                        if (isLightSource || neightLightSource) {
-                            finalResult = false;
-                        }
-                        tool.faceDataOverride.face = face;
-                        tool.faceDataOverride.default = finalResult;
-                        finalResult = OverrideManager.AO.run(tool.voxel.getShapeId(), tool.nVoxel.getShapeId(), tool.faceDataOverride);
-                        if (finalResult) {
-                            AOValues.a++;
-                        }
-                    }
-                }
-                checkSetIndex++;
-            }
-            /*
-         Light End
-         */
-            if (this.settings.doSun || this.settings.doRGB) {
-                newRGBValues[0] = sunValues.s;
-                newRGBValues[1] = RGBValues.r;
-                newRGBValues[2] = RGBValues.g;
-                newRGBValues[3] = RGBValues.b;
-                LightValue.setVertex(vertex, LD.setLightValues(newRGBValues));
-            }
-            /*
-         AO End
-         */
-            if (this.settings.doAO) {
-                AOValue.setVertex(vertex, Math.ceil((AOValues.a / 3) * 15));
-            }
-        }
-        tool
-            .setFaceFlipped(flipCheck(face))
-            .getWorldLight()
-            .set(LightValue.vertices[QuadVerticies.TopRight], LightValue.vertices[QuadVerticies.TopLeft], LightValue.vertices[QuadVerticies.BottomLeft], LightValue.vertices[QuadVerticies.BottomRight]);
-        if (!states.ignoreAO) {
-            tool
-                .getWorldAO()
-                .set(AOValue.vertices[QuadVerticies.TopRight], AOValue.vertices[QuadVerticies.TopLeft], AOValue.vertices[QuadVerticies.BottomLeft], AOValue.vertices[QuadVerticies.BottomRight]);
-        }
-    },
-};

package/Mesher/Constructors/Voxel/Classes/Cube/ModCube.constructor.d.ts

@@ -1,13 +0,0 @@
-import { VoxelMesherDataTool } from "../../../../Tools/VoxelMesherDataTool.js";
-import { VoxelConstructor } from "../VoxelConstructor.js";
-import { TextureRegister } from "../../../../../Textures/TextureRegister.js";
-import type { ConstructorTextureData } from "../../../../../Textures/Constructor.types.js";
-import { VoxelFaces } from "../../../../../Math/index.js";
-export declare class ModCubeVoxelConstructor extends VoxelConstructor {
-    id: string;
-    textureData: ConstructorTextureData[] | Record<VoxelFaces, ConstructorTextureData[]>;
-    textures: Record<VoxelFaces, number[]>;
-    constructor(id: string, textureData: ConstructorTextureData[] | Record<VoxelFaces, ConstructorTextureData[]>);
-    process(tool: VoxelMesherDataTool): void;
-    onTexturesRegistered(textureManager: typeof TextureRegister): void;
-}

package/Mesher/Constructors/Voxel/Classes/Cube/ModCube.constructor.js

@@ -1,77 +0,0 @@
-import { CubeVoxelShape } from "../../../../Shapes/default/Cube/Cube.voxel.shape.js";
-import { VoxelConstructor } from "../VoxelConstructor.js";
-import { VoxelFaces, VoxelFacesArray } from "../../../../../Math/index.js";
-export class ModCubeVoxelConstructor extends VoxelConstructor {
-    id;
-    textureData;
-    textures = {
-        [VoxelFaces.Up]: [],
-        [VoxelFaces.Down]: [],
-        [VoxelFaces.North]: [],
-        [VoxelFaces.South]: [],
-        [VoxelFaces.East]: [],
-        [VoxelFaces.West]: [],
-    };
-    constructor(id, textureData) {
-        super();
-        this.id = id;
-        this.textureData = textureData;
-    }
-    process(tool) {
-        tool.getOverlayTextures().setAll(0);
-        const shapeState = tool.voxel.getMod();
-        if (tool.isFaceExposed(VoxelFaces.Up)) {
-            tool
-                .setTexture(this.textures[VoxelFaces.Up][shapeState])
-                .calculateLight(VoxelFaces.Up);
-            CubeVoxelShape.add.up();
-        }
-        if (tool.isFaceExposed(VoxelFaces.Down)) {
-            tool
-                .setTexture(this.textures[VoxelFaces.Down][shapeState])
-                .calculateLight(VoxelFaces.Down);
-            CubeVoxelShape.add.down();
-        }
-        if (tool.isFaceExposed(VoxelFaces.East)) {
-            tool
-                .setTexture(this.textures[VoxelFaces.East][shapeState])
-                .calculateLight(VoxelFaces.East);
-            CubeVoxelShape.add.east();
-        }
-        if (tool.isFaceExposed(VoxelFaces.West)) {
-            tool
-                .setTexture(this.textures[VoxelFaces.West][shapeState])
-                .calculateLight(VoxelFaces.West);
-            CubeVoxelShape.add.west();
-        }
-        if (tool.isFaceExposed(VoxelFaces.South)) {
-            tool
-                .setTexture(this.textures[VoxelFaces.South][shapeState])
-                .calculateLight(VoxelFaces.South);
-            CubeVoxelShape.add.south();
-        }
-        if (tool.isFaceExposed(VoxelFaces.North)) {
-            tool
-                .setTexture(this.textures[VoxelFaces.North][shapeState])
-                .calculateLight(VoxelFaces.North);
-            CubeVoxelShape.add.north();
-        }
-    }
-    onTexturesRegistered(textureManager) {
-        const textures = this.textureData;
-        const push = (direction, ...textureIndex) => {
-            this.textures[direction].push(...textureIndex);
-        };
-        if (Array.isArray(textures)) {
-            for (const texture of textures) {
-                for (const face of VoxelFacesArray) {
-                    push(face, textureManager.getTextureUV(texture));
-                }
-            }
-            return;
-        }
-        for (const face of VoxelFacesArray) {
-            push(face, ...textures[face].map((_) => textureManager.getTextureUV(_)));
-        }
-    }
-}

package/Mesher/Constructors/Voxel/Classes/Cube/PillarCube.constructor.d.ts

@@ -1,27 +0,0 @@
-import type { ConstructorTextureData } from "../../../../../Textures/Constructor.types.js";
-import { VoxelMesherDataTool } from "../../../../Tools/VoxelMesherDataTool.js";
-import { VoxelConstructor } from "../VoxelConstructor.js";
-import { TextureRegister } from "../../../../../Textures/TextureRegister.js";
-export type PillarCubeVoxelConstructorData = {
-    top: ConstructorTextureData;
-    bottom: ConstructorTextureData;
-    sideMiddle: ConstructorTextureData;
-    sideBottom: ConstructorTextureData;
-    sideTop: ConstructorTextureData;
-    sideFloat: ConstructorTextureData;
-};
-export declare class PillarCubeVoxelConstructor extends VoxelConstructor {
-    id: string;
-    textureData: PillarCubeVoxelConstructorData;
-    textures: [
-        up: number,
-        down: number,
-        sideMiddle: number,
-        sideDown: number,
-        sideUp: number,
-        sideFloat: number
-    ];
-    constructor(id: string, textureData: PillarCubeVoxelConstructorData);
-    process(tool: VoxelMesherDataTool): void;
-    onTexturesRegistered(textureManager: typeof TextureRegister): void;
-}